---

Names

Almost all methods in the Context interface must process names. For consistency, you should use the same pattern in each method to process names. One way to achieve this conveniently is to define and use a utility method to process the input name. Two examples are given here, one for a context implementation of a flat namespace and one for a context implementation of a hierarchical namespace. Whether a context implementation supports a flat namespace or a hierarchical namespace is typically determined by the underlying naming/directory service or the requirements of the service provider.

As recommended in The Ground Rules lesson, for both examples, each method in the Context interface that accepts a java.lang.String name is defined simply to call its counterpart that accepts a Name. The rest of this discussion focuses on dealing with structured names.

 

 

A Flat Namespace Example

The first example implements a flat namespace and does not support federation. The methods that accept a Name use the following utility method to determine the components of the name that should be processed.

protected String getMyComponents(Name name) throws NamingException {
    if (name instanceof CompositeName) {
        if (name.size() > 1) {
	    throw new InvalidNameException(name.toString() +
		" has more components than namespace can handle");
	}
	return name.get(0);
    } else {
	// A compound name
	return name.toString();
    }
}

Because the context does not support federation, it accepts only single-component composite names or compound names. If it receives a multicomponent composite name, then it throws an InvalidNameException.

 

 

A Hierarchical Namespace Example

The second example implements a hierarchical namespace and does not support federation. The methods that accept a Name use the following utility method to determine the components of the name that should be processed.

protected Name getMyComponents(Name name) throws NamingException {
    if (name instanceof CompositeName) {
	if (name.size() > 1) {
	    throw new InvalidNameException(name.toString() +
		" has more components than namespace can handle");
	}

	// Turn component that belongs to you into a compound name
	return myParser.parse(name.get(0));
    } else {
	// Already parsed
	return name;
    }
}

Unlike in the flat namespace example, this method returns a Name that represents a structured compound name instead of a java.lang.String. When the method gets a CompositeName, it parses the first component into a compound name and returns it.