RTTI considered harmful?

Various

designs in this chapter attempt to remove RTTI, which might give you the

impression that it’s “considered harmful” (the condemnation

used for poor, ill-fated

,

which was thus never put into Java). This isn’t true; it is the

However,

RTTI doesn’t automatically create non-extensible code. Let’s

revisit the trash recycler once more. This time, a new tool will be introduced,

which I call a

.

It contains a

that holds

s,

but the interface is simple: you can

a new object, and you can

a

containing all the objects of a particular type. The keys for the contained

are the types in the associated

.

The beauty of this design (suggested by Larry O’Brien) is that the

dynamically adds a new pair whenever it encounters a new type, so whenever you

add a new type to the system (even if you add the new type at run-time), it

adapts.

Our

example will again build on the structure of the

types in

(and the

file used there can be used here without change):

//: DynaTrash.java 
// Using a Hashtable of Vectors and RTTI
// to automatically sort trash into
// vectors. This solution, despite the
// use of RTTI, is extensible.
package c16.dynatrash;
import c16.trash.*;
import java.util.*;
 
// Generic TypeMap works in any situation:
class TypeMap {
  private Hashtable t = new Hashtable();
  public void add(Object o) {
    Class type = o.getClass();
    if(t.containsKey(type))
      ((Vector)t.get(type)).addElement(o);
    else {
      Vector v = new Vector();
      v.addElement(o);
      t.put(type,v);
    }
  }
  public Vector get(Class type) {
    return (Vector)t.get(type);
  }
  public Enumeration keys() { return t.keys(); }
  // Returns handle to adapter class to allow
  // callbacks from ParseTrash.fillBin():
  public Fillable filler() {
    // Anonymous inner class:
    return new Fillable() {
      public void addTrash(Trash t) { add(t); }
    };
  }
}
 
public class DynaTrash {
  public static void main(String[] args) {
    TypeMap bin = new TypeMap();
    ParseTrash.fillBin("Trash.dat",bin.filler());
    Enumeration keys = bin.keys();
    while(keys.hasMoreElements())
      Trash.sumValue(
        bin.get((Class)keys.nextElement()));
  }
} ///:~ 

Although

powerful, the definition for

is simple. It contains a

,

and the

method does most of the work. When you

a new object, the handle for the

object for that type is extracted. This is used as a key to determine whether a

holding objects of that type is already present in the

.

If so, that

is extracted and the object is added to the

.

If not, the

object and a new

are added as a key-value pair.

You

can get an

of all the

objects from

,

and use each

object to fetch the corresponding

with

.

And that’s all there is to it.

The

method is interesting because it takes advantage of the design of

,

which doesn’t just try to fill a

but instead anything that implements the

interface with its

method. All

needs to do is to return a handle to an

that implements

,

and then this handle can be used as an argument to

like this:

To

produce this handle, an

An

interesting thing about this design is that even though it wasn’t created

to handle the sorting,

is performing a sort every time it inserts a

object into

.

Much

of

should be familiar from the previous examples. This time, instead of placing

the new

objects into a

of type

,

the

is of type

,

so when the trash is thrown into

it’s immediately sorted by

’s

internal sorting mechanism. Stepping through the

and operating on each individual

becomes a simple matter:

    Enumeration keys = bin.keys();
    while(keys.hasMoreElements())
      Trash.sumValue(
        bin.get((Class)keys.nextElement()));

As

you can see, adding a new type to the system won’t affect this code at

all, nor the code in

.

This is certainly the smallest solution to the problem, and arguably the most

elegant as well. It does rely heavily on RTTI, but notice that each key-value

pair in the

is looking for only one type. In addition, there’s no way you can

“forget” to add the proper code to this system when you add a new

type, since there isn’t any code you need to add.

|

|