AttributeSet The Value Objects

The basic idea is that you should avoid network latency whenever reasonable. Related contexts and paths that are frequently accessed as units should exist on a single machine, and should probably exist inside a single JVM. This means that, in daily use of a naming service with a well- structured context hierarchy, the following case holds: Most of the frequently accessed subcontexts of any given context will be objects inside the same JVM. [ 4] [ 4] That is, Federation is very useful and rarely used. In order to support this in a flexible way, a context needs to be able to create subcontexts directly; since bind cannot create an object inside another JVM, we need the createSubContext method. createSubContext also implicitly binds the created subcontext.

15.4.8 There Are No Remote Iterators

This is another decision based on past experience and anticipated usage and may be removed quickly in Version 2.0. Basically, the idea is that with the addition of a well-designed set of attributes, queries should have very few return values of which, even fewer are superfluous. This means, in the general case, iterators would make the clients more complex without saving us much bandwidth. For now, the interface seems complicated enough.

15.5 The Value Objects

There are three value objects: AttributeSet , Path , and ContextList . As I mentioned earlier, one of the reasons for implementing our own container objects is to preserve flexibility. However, these objects™especially AttributeSet ™also have other functionalities.

15.5.1 AttributeSet

An instance of AttributeSet represents a set of name-value pairs which can be queried. That is, when a client calls: public Remote[] listPath path, String name, AttributeSet attributes throws RemoteException, NamingException; the server is supposed to do the following: • Find the context associated with path . • Find all the objects that were bound into the path context as servers not as contexts using name . There can be more than one, as long as the attributes are different. • From those objects, pull out the ones that match attributes . By match, I mean, It has the same values for all individual name-value pairs set in attributes. But the match may have additional name-value pairs that are not defined in attributes . In order to do this, weve made AttributeSet into a fairly sophisticated object with four main features: • An instance of AttributeSet stores name-value pairs. • AttributeSet implements Serializable . • AttributeSet s are comparable and can be sorted. • An instance of AttributeSet can tell whether it is a superset of another instance of AttributeSet in a reasonably efficient way. The first two features are easy to implement. The last two are more difficult, and the implementation is a little complicated. We start by storing all the name-value pairs inside an instance of TreeMap : public class AttributeSet implements Serializable, Comparable { private TreeMap _underlyingMap; public AttributeSet { _underlyingMap = new TreeMap ; } public synchronized void addString name, String value { if null==name { return; } if null==value { _underlyingMap.removename; } else { _underlyingMap.putname, value; } } public synchronized void removeString name { _underlyingMap.removename; } public synchronized int getSize { return _underlyingMap.size ; } public synchronized Iterator getNames { return _underlyingMap.keySet.iterator ; } public synchronized String getValueString name { return String _underlyingMap.getname; } public synchronized boolean containsString name { return null=_underlyingMap.getname; } public synchronized boolean containsString name, String value { String internalValue = String _underlyingMap.getname; if null=internalValue { return internalValue.equalsvalue; } return null==value; } .... } TreeMap TreeMap is a class in the java.util package that implements the Map interface. Map itself is pretty simple. Its just an interface version of the methods that were defined on Hashtable in JDK1.02. In particular, most uses of a map boil down to using five methods: public Object getObject key public boolean isEmpty public Set keySet public Object putObject key, Object value public Collection values TreeMap implements Map by using a tree data structure internally. As such, it has the following features: • It sorts entries internally, using either a Comparator or assuming the entries implement the Comparable interface also defined in the java.util package. • Iterating over the keys or values of a TreeMap is fast, especially compared to the same operations done using HashMap . • Insertion, removal, and lookup operations are Onlogn , where n is the number of entries in the TreeMap . Also note that TreeMap implements Serializable , as do most of the Collections classes. Once we have the data in place, we need to implement comparison operations. In particular, we need to be able to tell the following three things: • Whether two instances of AttributeSet are equal • Whether one instance of AttributeSet is a subset of another • Whether one instance of AttributeSet is less than another, using an artificial ordering we impose to help with lookups These first two are pretty straightforward. Two instances of AttributeSet are equal if they consist of the same name-value pairs. In addition, AttributeSet A is a subset of AttributeSet B if every name-value pair in A is also in B . The third of these bulleted properties isnt logically necessary. We need it because we want to be able to use instances of TreeMap to store bindings in our naming service. TreeMap offers a nice compromise between fast lookupremovalinsertion and the ability to enumerate. However, in order to use them, we need the objects we insert to be ordered. Itd be nice to define an order on AttributeSet s such that if A is greater than B , then A cannot be a partial match for B ™that would make our query functionality significantly faster than it is currently. Unfortunately, such an example would be far too complicated for this book. Heres the rest of the code for AttributeSet : public synchronized boolean equalsObject object { if false == object instanceof AttributeSet { return false; } return 0 == compareTo object; } public synchronized boolean subsetOfAttributeSet otherAttributeSet { Iterator i = getNames ; while i.hasNext { String name = String i.next ; String value = getValuename; if false == otherAttributeSet.containsname, value { return false; } } return true; } public synchronized int compareToObject object { AttributeSet otherAttributeSet = AttributeSetobject; int sizeDifferential = _underlyingMap.size - otherAttributeSet.getSize ; if 0=sizeDifferential { return sizeDifferential 0 ? -1 : 1 ; doesnt matter as long as were consistent. } Iterator otherIterator = otherAttributeSet.getNames ; Iterator internalIterator = getNames ; while otherIterator.hasNext { String foreignName = String otherIterator.next ; String internalName = StringinternalIterator.next ; int firstComparison = internalName.compareToforeignName; if 0 = firstComparison { return firstComparison; } String foreignValue = otherAttributeSet.getValueforeignName; String internalValue = getValueforeignName; int secondComparison = internalValue.compareToforeignValue; if 0 = secondComparison { return secondComparison; } } return 0; }

15.5.2 Path and ContextList