visitor

Recently I got into implementing a message dispatching system that uses the "Observer pattern": nothing special here. As I developed it I thought it would be nice to send "Message" objects from the "subject" that could be fundamentally different from each other and could be read from the many "observers". These different messages took the form of different message classes (for example, think about the "User Logout message", "Screen mode toogle" and "Volume level changed", all of these need different information) and soon I found that the "observers" needed not to know about every different

As I understand it, in the typical specification of the Visitor pattern, it is the visited objects that decide how to traverse, and generally, they only support one traversal order. (See, e.g., here or here .) Is there a name for the same use of double-dispatch, but where the Visitors get to decide how to traverse the object-hierarchy? In my application, a very heterogeneous collection of document-model types is pushing towards visitors for, e.g., export operations. It seems rigid, though, to say that the various processors (visitors) should all traverse in, say, a breadth-first order. Some of

Would you say that Objective-C categories are an implementation of the visitor design pattern ? No, Objective-C categories are not an implementation of the visitor pattern. Categories don't really have an exact match in the design pattern world, since the technique of injecting methods into existing classes without subclasses isn't possible in most languages. I'd say it's closer to the decorator pattern , but that pattern is usually implemented with composition, i.e. by wrapping an instance of the object you want to "enhance". The visitor pattern is useful for encapsulating algorithm logic

I've seen a couple of examples that demonstrate the visitor pattern. In all of them, each derived visited element implements what's usually called the Accept() method. In a hierarchy of colors, this method might look like: void Red::accept(Visitor *v) { v->visit(*this); } void Blue::accept(Visitor *v) { v->visit(*this); } When Visitor, as well as its inheritors, have the methods: visit(Red red); visit(Blue blue) My question is why not implement this in the same way only in the base class (in this example: Color ) and polymorphism will do the job, namely, the correct visit will be called since

Is the following java implementation of the visitor pattern using generics, general enough to be useful? (I suppose it is). Could it be improved in some way? It's important to be easily call-able using anonymous classes. Thanks. (Example of use): Vector<Number> numbers = new Vector<Number>(); numbers.add(new Double(1.2)); numbers.add(new Float(-1.2)); numbers.add(new Double(4.8)); numbers.add(new Float(-3.4)); numbers.add(new Long(123456)); numbers.add(new Short("14")); For.each(numbers, new Visitor<Number>() { public void doIt(Double n) { System.out.println("doIt() for double: " + n); }