Re: Wormholes

In article <k23nn7$urk$1@dont-email.me>, eric@invalid.com says...


Let's see, you need to get Information from A to C:

The Law of Demeter incompliant naive solution:

class A{
 private B b = new B();
 {
  b.getC().setValue("hello world");
 }
}

class B{
 private C c = new C();
 C getC(){return c;}
}

class C{
  private String value;
  void setValue(String v){c.setValue(v);}
}

Problem: if you change C, you need to change A aswell, eveb though these
should not be closely related.

LOD-compliant naive solution:

class A{
  private B b = new B();
 {
  b.setValue("hello world")
 }
}

class B{
  private C c = new C();
  void setValue(String v){c.setValue(v);}
}

class C{
  private String value;
  void setValue(String v){c.setValue(v);}
}

The only difference with the previous is that B won't leak its internals
to A, so you could change C without affecting A, by putting some
conversion code to B.

You could use a visitor too:

class Visitor{
 private String value;
 Visitor(String value){this.value=value;}

 void visit(C c){
  c.setValue(value);
 }
}

class A{
 private B b = new B();
 {
  b. accept(new Visitor("Hello World"));
 }
}

class B{
 private C c = new C();
 accept(Visitor v){
  c.accept(v);
 }
}

class C{
 private String value;
 accept(Visitor v){
  v.visit(this);
 }
}

This way your can change C without having to change A or B, by adding
some conversion code to the Visitor.

The third thing you could do is send Messages over a central message
bus, that every class may listen to:

interface MessageBusStop{
 void stop(Bus bus);
}

abstract Message{
 private Object id;
 private Object payload;
 Message(Object id, Object payload){
  this.id=id;
  this.payload=payload;
 }
 boolean isMessageId(Object id){this.id.equals(id);}
 Object getPayload(){return payload;}
}

class A{
 Bus bus = Application.getMessageBus();
 {
 bus.sendMessage(new Message(Messages.NEW_TITLE,"Hello World"));
 }
}

class C implements MessageBusStop{
 private String s;
 private Bus bus = Application.registerNewMessageBusStop(this);

 void stop(Bus b){
  if(b.isMessageId(Messages.NEW_TITLE)){
   s = (String)bus.peekMessagePayload();
  }
 }
}

Problem is that a single message may involve a lot of classes to see if
they are responsible to handle the message, but there are possibilities
to make the central bus only stop at those classes interested in certain
IDs or certain types of IDs, so this concept is pretty nice.
The problem there is with many objects reactibng to messages that you
have to make sure that the order in which objects react to messages is
not crucial.

Kind regards,
Wanja

--
...Alesi's problem was that the back of the car was jumping up and down
dangerously - and I can assure you from having been teammate to
Jean Alesi and knowing what kind of cars that he can pull up with,
when Jean Alesi says that a car is dangerous - it is. [Jonathan Palmer]

--- Posted via news://freenews.netfront.net/ - Complaints to news@netfront.net ---