DJ: Dynamic Structure-Shy Traversals and Visitors in Pure Java

DJ API | DJ Information for Software Contributors.

DJ: Dynamic Adaptive Programming in Java. This is a good introductory paper for potential DJ users.
Aspect-Oriented Programming with Adaptive Methods. This is a good introductory paper for potential DJ users who are interested in the emerging field of Aspect-Oriented Programming.
Traversal Semantics in Object Graphs. This is a good paper to learn about the precise definition and semantics of traversal strategies.

DJ already enjoys an active user community. We have substantial teaching material available. DJ is in pre 1.0 phase and is stable enough to be used in undergraduate classes. We don't expect the DJ interface to change in a non-upward-compatible way.
Home Directory of an undergraduate class that uses DJ (Winter 2001) .
Home Directory of a graduate class that uses DJ (Fall 2000) .
Home Directory of an undergraduate class that uses DJ (Fall 2000) .

Note: Demeter/Java is now called DemeterJ.

The Visitor pattern from GOF has significantly gained in popularity in recent years. The Visitor pattern allows you to add code to your classes without changing the classes. We have used various instantiations of the Visitor pattern since 1985. Based on this experience, we offer DJ as a tool that makes programming with visitors significantly easier. DJ allows you to both name traversals and visitors and to reuse them. Traversal reuse is useful: for example, if you buy a HP printer you buy printer installation software that uses traversal-visitor programming where each traversal is reused at least four times (check the Hewlett-Packard success story (http://www.ccs.neu.edu/research/demeter/evaluation/conventional-env/hp.html) for further information). One of the distinguishing features of DJ is that it makes traversal programming very easy. DJ uses the traversal strategy language for specifying navigation through objects. This language has evolved since 1991 from a small sublanguage of Demeter/C++ to a small sublanguage of DemeterJ. DJ uses the same traversal strategy language as DemeterJ.

Note: A traversal strategy has nothing to do with the GOF strategy pattern. A traversal strategy is about strategically defining a traversal through objects. Sometimes we use "strategy" instead of "traversal strategy". You can think of a strategy as a specification of an iterator through a structure more complex that a collection.

DJ effectively lets you write each behavior against a generic data model and lets you map the behavior into a concrete data model. This is a well-known pattern used in modern component-based sofware development and leads to both simpler and more reusable designs and programs.

DJ allows you to define Java Collections using traversal strategies. What is important is that the iterators operate directly on the original objects and no extra collection objects are created.

A word of caution regarding the applicability of DJ: DJ heavily uses reflection in its current implementation. This makes the implementation slow but simple. DJ is an ideal rapid prototyping tool for the Java programmer. A Java program using DJ can be systematically rewritten into a more efficient Java program by writing traversals manually.

DJ is the little sister of DemeterJ. While DemeterJ requires you to use a non-standard environment with class dictionary files and behavior files, DJ fits seamlessly into Java development environments. All you need to do is to import the edu.neu.ccs.demeter.dj package into your Java programs and you will be able to program in a traversal-visitor style. The DJ package provides essentially the following method:

// class ClassGraph
Object traverse(Object o, Strategy s, Visitor v);

// class ClassGraph
Object fetch(Object o, Strategy s);

// class ClassGraph
List gather(Object o, Strategy s);

To give users feedback about the traversals the strategies define, DJ allows users to print the traversal graphs.

DJ uses a reflective approach to implementing strategies and visitors. Visitor classes must be subclasses of class Visitor which contains the following methods:

void before(A host) {}; // code executed before entering A-objects
void after(A host) {}; // code executed after leaving A-objects

void before_p(P source, Q dest) {}; // unimplemented as of
void after_p(P source, Q dest) {};  // version 0.8.1

void start() {};
void finish() {};

Object getReturnValue() {};

• ClassGraph,
• Strategy,
• TraversalGraph,
• ObjectGraph, and
• ObjectGraphSlice.
• DJ API.

import edu.neu.ccs.demeter.dj.*;

class Main {
  public static void main(String[] args) {
    ClassGraph cg = new ClassGraph(); // constructed by reflection from
                                      // the classes in the default package
    // construct some object
    A a = new A(new B(new D()), new C());

    Strategy sg = new Strategy("from A to D");
    TraversalGraph tg = new TraversalGraph(sg, cg);

    // notice that Java allows you to inline the visitor
    // if you don't need the visitor object after the traversal
    tg.traverse(a, new Visitor() {
	public void start() { System.out.println("begin");}
	public void finish() { System.out.println("end"); }

        public void before(A o) { System.out.println("before A"); }
        public void after(A o)  { System.out.println("after A"); }

        public void before(D o) { System.out.println("before D"); }
        public void after(D o)  { System.out.println("after D"); }
    }); 

    // Print out the traversal graph so that you 
    // can check the detailed traversal
    System.out.println("Traversal Graph for from A to D");
    System.out.println(tg);        
  }
}

// from class Main:
ClassGraph cg=new ClassGraph();
TraversalGraph tg
  = new TraversalGraph("from UMLDiagram via Abstract to Vertex", cg);
CountInhRelsVisitor v = new CountInhRelsVisitor();
tg.traverse(cd_graph, v);

// class CountInhRelsVisitor
import edu.neu.ccs.demeter.dj.Visitor;
public class CountInhRelsVisitor extends Visitor
{	
	public int iCount;
	public void start() { System.out.println("begin"); iCount = 0;}
	public void finish() {	
		 System.out.println("The total count = " + iCount);
		 System.out.println("end"); }
	public void before(Vertex o) { iCount++; }
}

• Browse the source code:
  • version 0.8.6
• Download and installation:
  • Installation guide
• How to use the next version with more features
  • Alpha version of DJ