Hi Kedar:

With the success of AP Studio at the EDCS demo, we need now a way
to visualize traversal graphs. I think that the best approach is 
to approximate the traversal graph in the class graph. In many
cases the approximation will be a faithful representation of
the path set defined by the strategy
(i.e., the old propagation graph which AP Studio
already does). If the representation is not faithful, a message should
be given. You need a consistency checker for this
which is already implemented in Demeter/C++ for series-parallel graphs.

I propose the following way to map a traversal graph into a class graph:

The edge:
X$n1__A$n2__B = <b> Y$m1__C$m2__D.
is mapped into the class graph edge:
X = <b> Y.

(see an explanation of the notation below.)
Maybe you can allow the user to click on a propagation graph
edge and show the user which strategy graph edges are responsible for 
that edge. Often it will be only one.

-- Karl
=========================
Hi Doug:

we need to discuss a suitable notation for traversal graphs for the
following reasons:

1. APStudio needs to read the traversal graphs you compute by visualizing
   them in the class graph. I suggest that you generate a directory
   called traversal-graphs which contains files of the form:
   *.trv. Each file should contain the strategy which was used to produce
   the traversal graph.

2. The visitor code may want to refer to the active strategies (token set).

3. Traversal graphs are useful for a variety of other tasks like checking
   whether a change in class graph implies a change in the path set
   (evolution).

I think that a textual form of a traversal graph should use 
our familiar graph notation: the class graph notation.
The issue is how to name the nodes in the traversal graph.

I think a node name in a traversal graph should have the following form:
X$m$n, where X is a class name and m and n are node names in a strategy
with an optional class name seperated by __.
$ plays the role of a separator. It is a legal letter in Java.

Example: X$n1__A$n2__B
is a node in a traversal graph which corresponds to class X in
the class graph and which is "caused" by the strategy edge
from node n1 to node n2 in the strategy graph. The __ with class name
is optional and indicates how the strategy graph is mapped into the class
graph. In the above example, n1 is mapped to A and n2 is mapped to B.

If the default mapping is used (each node in the class graph
appears at most once in the strategy graph, i.e., the name map is
one-to-one) then we can delete the __ part: X$A$B.
This means that the traversal of the X-object is caused by the strategy
edge from A to B.

Regarding the visitors, I suggest that we use a strategies argument
for every traversal. The visitors can query the token set with:

if (strategies.active({"A$B","A$C"})) { ... }
or
if (strategies.active({"x__A$y__B","r__A$s__C"})) { ... }

The argument is an array of type String[].

How does this look to you? I am not so happy with __ since it can lead
to ambiguities especially in the presence of expanded parameterized classes.

-- Karl