Home » openjdk-7 » javax » naming » [javadoc | source]
javax.naming
public interface: Name [javadoc | source]

All Implemented Interfaces:
    Comparable, Cloneable, Serializable

All Known Implementing Classes:
    CompositeName, CompoundName, LdapName

The Name interface represents a generic name -- an ordered sequence of components. It can be a composite name (names that span multiple namespaces), or a compound name (names that are used within individual hierarchical naming systems).

There can be different implementations of Name; for example, composite names, URLs, or namespace-specific compound names.

The components of a name are numbered. The indexes of a name with N components range from 0 up to, but not including, N. This range may be written as [0,N). The most significant component is at index 0. An empty name has no components.

None of the methods in this interface accept null as a valid value for a parameter that is a name or a name component. Likewise, methods that return a name or name component never return null.

An instance of a Name may not be synchronized against concurrent multithreaded access if that access is not read-only.

Field Summary
static final  long serialVersionUID    The class fingerprint that is set to indicate serialization compatibility with a previous version of the class. 
Method from javax.naming.Name Summary:
add,   add,   addAll,   addAll,   clone,   compareTo,   endsWith,   get,   getAll,   getPrefix,   getSuffix,   isEmpty,   remove,   size,   startsWith
Method from javax.naming.Name Detail:
 public Name add(String comp) throws InvalidNameException
    Adds a single component to the end of this name.
 public Name add(int posn,
    String comp) throws InvalidNameException
    Adds a single component at a specified position within this name.
Components of this name at or after the index of the new component
are shifted up by one (away from index 0) to accommodate the new
component.
 public Name addAll(Name suffix) throws InvalidNameException
    Adds the components of a name -- in order -- to the end of this name.
 public Name addAll(int posn,
    Name n) throws InvalidNameException
    Adds the components of a name -- in order -- at a specified position
within this name.
Components of this name at or after the index of the first new
component are shifted up (away from 0) to accommodate the new
components.
 public Object clone()
    Generates a new copy of this name.
Subsequent changes to the components of this name will not
affect the new copy, and vice versa.
 public int compareTo(Object obj)
    Compares this name with another name for order.
Returns a negative integer, zero, or a positive integer as this
name is less than, equal to, or greater than the given name.


     As with Object.equals(), the notion of ordering for names
depends on the class that implements this interface.
For example, the ordering may be
based on lexicographical ordering of the name components.
Specific attributes of the name, such as how it treats case,
may affect the ordering.  In general, two names of different
classes may not be compared.
 public boolean endsWith(Name n)
    Determines whether this name ends with a specified suffix.
A name n is a suffix if it is equal to
getSuffix(size()-n.size()).
 public String get(int posn)
    Retrieves a component of this name.
 public Enumeration<String> getAll()
    Retrieves the components of this name as an enumeration
of strings.  The effect on the enumeration of updates to
this name is undefined.  If the name has zero components,
an empty (non-null) enumeration is returned.
 public Name getPrefix(int posn)
    Creates a name whose components consist of a prefix of the
components of this name.  Subsequent changes to
this name will not affect the name that is returned and vice versa.
 public Name getSuffix(int posn)
    Creates a name whose components consist of a suffix of the
components in this name.  Subsequent changes to
this name do not affect the name that is returned and vice versa.
 public boolean isEmpty()
    Determines whether this name is empty.
An empty name is one with zero components.
 public Object remove(int posn) throws InvalidNameException
    Removes a component from this name.
The component of this name at the specified position is removed.
Components with indexes greater than this position
are shifted down (toward index 0) by one.
 public int size()
    Returns the number of components in this name.
 public boolean startsWith(Name n)
    Determines whether this name starts with a specified prefix.
A name n is a prefix if it is equal to
getPrefix(n.size()).