Hi Mira:

giving strategies as arguments to adjustments seems a good idea.

we can use:

strategy s

or something like:

strategy s = {A -> B, B -> {C,D}}
and then we can refer to A,B,C and D in the adjustments.
This will restrict the visitor to be used with strategies of the abive form.

Here I view A,B,C,D as class-valued variables which are mapped
to classes later.

What is not yet clear to me is what the benefits are of giving up
the "context" object idea. It seems natural to use the oo principles
also for the behavior modifications? What is wrong with that?
What are we losing?

How can we add data members to the traversed data for duration of a call?

-- Karl


Example 2: Container
--------------------

For the container example the summing adjuster above can  be reused. The
strategy now is

S1 = from Container to Weight;

adjuster CHECK(strategy s)
   adjustment SummingEntry {
            (@ int total_sum; @)
           init (@ total_sum = 0; @)
           return (@ total_sum @)
        }

     adjustment Sum(int total_sum)
        { change target(s) (@ total_sum += this.value; super(); @)}

   adjustment Initial modifies Summing {
	(@ int initial;
	   Stack stack; @)
	change source(s)
	  (@ stack.push(this.total_sum);
	     super();
	     initial = (Integer) stack.pop(); @)
   }

   adjustment Checking modifies Initial
    {
	(@ int violations;@)
	change source(s) (@ System.out.println(" start new container ");   
		  super();
		  integer initial = this.initial; 
		  int cap = this.get_capacity().get_i().intValue();
		  int diff = total_sum.intValue() - initial.intValue();
		  if (diff > cap)
 	   	     { violations = new Integer(violations.intValue() + 1);
	// this.set_violations(new Integer(violations.intValue() + 1));
        		System.out.println(" total weight " + 
        		diff + " but limit is = " + cap + " OVER CAPACITY "); };
    		  System.out.println(" end container "); 
	}


Container c = new Container{CHECK during S1}.
c.checking(). 


USING CLASS VALUED VARIABLES
--------------------

S1 = from Container, Weight

adjuster CHECK(strategy s = {Container ->  Weight})
   adjustment SummingEntry {
            (@ int total_sum; @)
           init (@ total_sum = 0; @)
           return (@ total_sum @)
        }

     adjustment Sum(int total_sum)
        { change Weight (@ total_sum += this.value; super(); @)}

   adjustment Initial modifies Summing {
	(@ int initial;
	   Stack stack; @)
	change Container
	  (@ stack.push(this.total_sum);
	     super();
	     initial = (Integer) stack.pop(); @)
   }

   adjustment Checking modifies Initial
    {
	(@ int violations;@)
	change Container (@ System.out.println(" start new container ");   
		  super();
		  integer initial = this.initial; 
		  int cap = this.get_capacity().get_i().intValue();
		  int diff = total_sum.intValue() - initial.intValue();
		  if (diff > cap)
 	   	     { violations = new Integer(violations.intValue() + 1);
	// this.set_violations(new Integer(violations.intValue() + 1));
        		System.out.println(" total weight " + 
        		diff + " but limit is = " + cap + " OVER CAPACITY "); };
    		  System.out.println(" end container "); 
	}


Container c = new Container{CHECK during S1}.
c.checking().