| The Essential Components

## Name Parser

> Whether a context implementation supports a flat or hierarchical namespace depends on the underlying naming/directory service. For example, a context implementation for an LDAP directory service must support a hierarchical namespace, whereas a context implementation for the RMI registry must support a flat namespace because the underlying services dictate that.

> A context implementation for a flat or hierarchical namespace needs a name parser, is a class that implements the `NameParser` interface. The JNDI provides a utility class, `CompoundName`, for developers to use when implementing `NameParser`. However, you are not required to use `CompoundName`. You can implement `NameParser` in any way as long as its `parse()` method returns an object that implements the `Name` interface. You should avoid using the `CompositeName` class for this purpose because it would be interpreted as a composite name.

> The hierarchical namespace example implements a syntax of right-to-left, dot-character (".") separated names. Here is its implementation of the `NameParser` interface.

> >     class HierParser implements NameParser {

> >         private static final Properties syntax = new Properties();
> >         static {
> >             syntax.put("jndi.syntax.direction", "right_to_left");
> >     	syntax.put("jndi.syntax.separator", ".");
> >             syntax.put("jndi.syntax.ignorecase", "false");
> >     	syntax.put("jndi.syntax.escape", "\\");
> >     	syntax.put("jndi.syntax.beginquote", "'");
> >         }

> >         public Name parse(String name) throws NamingException {
> >             return new CompoundName(name, syntax);
> >         }
> >     }

> The `CompoundName` class specifies properties that are used to define a naming syntax. For example, you can specify a syntax's atomic component separator, its escape and quotation characters, and whether the components are parsed right to left or left to right or are flat. Namespace syntax is determined by the underlying naming/directory service. You can use `CompoundName` only if the syntax of the underlying naming/directory service fits into `CompoundName`'s syntax model.

> The API user uses `Context.getNameParser()` to get a `Context` instance's name parser. The example implementation first performs a `lookup()` to verify that the input name is valid. It then returns the constant field `myParser`.

> >     public NameParser getNameParser(Name name) throws NamingException {
> >         // Do lookup to verify that the name exists
> >         Object obj = lookup(name);
> >         if (obj instanceof Context) {
> >             ((Context)obj).close();
> >         }
> >         return myParser;
> >     }

> Each context implementation has only one instance of `HierParser`:

> >     protected final static NameParser myParser = new HierParser();

> This is done to satisfy the JNDI specification, which requires that a context implementation return a `NameParser` whose `equals()` method returns `true` for all `Context` instances from the same namespace. This requirement is useful for supporting federation. Even though this example does not support federation, the requirement is easy to fulfill.

| The Essential Components