* A path is made up of zero or more elements each of which represents * a managed object. Managed objects are arranged hierarchically with * the root configuration being the top-most managed object. Elements * are ordered such that the root configuration managed object is the * first element and subsequent elements representing managed objects * further down the hierarchy. *
* A path can be encoded into a string representation using the * {@link #toString()} and {@link #toString(StringBuilder)} methods. * Conversely, this string representation can be parsed using the * {@link #valueOf(String)} method. *
* The string representation of a managed object path is similar in * principle to a UNIX file-system path and is defined as follows: *
/
* / character
* relation=relation
* [+type=definition], where
* relation is the name of the relation and definition
* is the name of the referenced managed object's definition if
* required (usually this is implied by the relation itself)
* relation=relation[+type=
* definition]+name=name,
* where relation is the name of the relation and
* definition is the name of the referenced managed object's
* definition if required (usually this is implied by the relation
* itself), and name is the name of the managed object
* instance
* relation=relation[+type=
* definition],
* where relation is the name of the relation and
* definition is the name of the referenced managed object's
* definition.
* type is not
* specified indicating that the path identifies a connection handler
* called my handler which can be any type of connection
* handler):
*
* * /relation=connection-handler+name=my handler ** * If the identified connection handler must be an LDAP connection * handler then the above path should include the
type:
*
* * /relation=connection-handler+type=ldap-connection-handler+name=my handler ** * The final example identifies the global configuration: * *
* /relation=global-configuration ** * @param
name.
*
* @param
* When the path is empty, the {@link RootCfgDefn} is returned.
*
* @return Returns the definition of the managed object referred to
* by this path, or the {@link RootCfgDefn} if the path is
* empty.
*/
public AbstractManagedObjectDefinition
* If there path does not refer to an instantiable managed object
*
* When the path is empty, the
* This method differs from
* The path elements will be passed to the serializer in big-endian
* order: starting from the root element and proceeding down to the
* leaf.
*
* @param serializer
* The managed object path serialization strategy.
*/
public void serialize(ManagedObjectPathSerializer serializer) {
for (Element element : elements) {
element.serialize(serializer);
}
}
/**
* Get the number of path elements in this managed object path.
*
* @return Returns the number of path elements (0 - means no offset,
* 1 means the parent, and 2 means the grand-parent).
*/
public int size() {
return elements.size();
}
/**
* Creates a DN representation of this managed object path.
*
* @return Returns a DN representation of this managed object path.
*/
public DN toDN() {
// Use a simple serializer to create the contents.
DNSerializer serializer = new DNSerializer();
serialize(serializer);
return serializer.toDN();
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
toString(builder);
return builder.toString();
}
/**
* Appends a string representation of this managed object path to
* the provided string builder.
*
* @param builder
* Append the string representation to this builder.
* @see #toString()
*/
public void toString(final StringBuilder builder) {
if (isEmpty()) {
// Special treatment of root configuration paths.
builder.append('/');
} else {
// Use a simple serializer to create the contents.
ManagedObjectPathSerializer serializer = new StringSerializer(builder);
serialize(serializer);
}
}
}
null is returned.
*
* @return Returns the name of the managed object referred to by
* this path, or null if the managed object
* does not have a name.
*/
public String getName() {
if (elements.isEmpty()) {
return null;
} else {
return elements.get(elements.size() - 1).getName();
}
}
/**
* Get the relation definition of the managed object referred to by
* this path.
* null is returned.
*
* @return Returns the relation definition of the managed object
* referred to by this path, or the null if
* the path is empty.
*/
public RelationDefinition getRelationDefinition() {
return r;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return toString().hashCode();
}
/**
* Determine whether or not this path contains any path elements.
*
* @return Returns true if this path does not contain
* any path elements.
*/
public boolean isEmpty() {
return elements.isEmpty();
}
/**
* Determines whether this managed object path references the same
* location as the provided managed object path.
* equals in that it ignores
* sub-type definitions.
*
* @param other
* The managed object path to be compared.
* @return Returns true if this managed object path
* references the same location as the provided managed
* object path.
*/
public boolean matches(ManagedObjectPath other) {
DN thisDN = toDN();
DN otherDN = other.toDN();
return thisDN.equals(otherDN);
}
/**
* Creates a new parent managed object path representing the
* immediate parent of this path. This method is a short-hand for
* parent(1).
*
* @return Returns a new parent managed object path representing the
* immediate parent of this path.
* @throws IllegalArgumentException
* If this path does not have a parent (i.e. it is the
* empty path).
*/
public ManagedObjectPath parent() throws IllegalArgumentException {
return parent(1);
}
/**
* Creates a new parent managed object path the specified number of
* path elements above this path.
*
* @param offset
* The number of path elements (0 - means no offset, 1
* means the parent, and 2 means the grand-parent).
* @return Returns a new parent managed object path the specified
* number of path elements above this path.
* @throws IllegalArgumentException
* If the offset is less than 0, or greater than the
* number of path elements in this path.
*/
public ManagedObjectPath parent(int offset)
throws IllegalArgumentException {
if (offset < 0) {
throw new IllegalArgumentException("Negative offset");
}
if (offset > elements.size()) {
throw new IllegalArgumentException(
"Offset is greater than the number of path elements");
}
// An offset of 0 leaves the path unchanged.
if (offset == 0) {
return this;
}
// Return the empty path if the parent has zero elements.
if (elements.size() == offset) {
return emptyPath();
}
LinkedList