org.opendaylight.mdsal.binding.javav2.spec.base

Class InstanceIdentifier<T extends TreeNode>

java.lang.Object

org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier<T>

All Implemented Interfaces:

Serializable, org.opendaylight.yangtools.concepts.Immutable, org.opendaylight.yangtools.concepts.MutationBehaviour<org.opendaylight.yangtools.concepts.Immutable>, org.opendaylight.yangtools.concepts.Path<InstanceIdentifier<? extends TreeNode>>

Direct Known Subclasses:

KeyedInstanceIdentifier

@Beta
public class InstanceIdentifier<T extends TreeNode>
extends Object
implements org.opendaylight.yangtools.concepts.Path<InstanceIdentifier<? extends TreeNode>>, org.opendaylight.yangtools.concepts.Immutable, Serializable

This instance identifier uniquely identifies a specific TreeNode in the data tree modeled by YANG. For Example let's say you were trying to refer to a node in inventory which was modeled in YANG as follows,

 module opendaylight-inventory {
      ....

      container nodes {
        list node {
            key "id";
            ext:context-instance "node-context";

            uses node;
        }
    }

 }
 

You could create an instance identifier as follows to get to a node with id "openflow:1" InstanceIdentifierBuilder.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId("openflow:1")).build(); This would be the same as using a path like so, "/nodes/node/openflow:1" to refer to the openflow:1 node

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected Iterable<TreeArgument>	pathArguments

Method Summary

Modifier and Type	Method and Description
protected com.google.common.base.MoreObjects.ToStringHelper	addToStringAttributes(com.google.common.base.MoreObjects.ToStringHelper toStringHelper) Add class-specific toString attributes.
<N extends TreeNode & Augmentation<? super T>> InstanceIdentifier<N>	augmentation(Class<N> container)
InstanceIdentifierBuilder<T>	builder() Create a builder rooted at this key.
static <N extends TreeChildNode<? extends TreeRoot,?>,K> InstanceIdentifierBuilder<N>	builder(Class<N> listItem, K listKey) Create an InstanceIdentifierBuilder for a specific type of InstanceIdentifier which represents an IdentifiableItem
static <T extends TreeChildNode<? extends TreeRoot,?>> InstanceIdentifierBuilder<T>	builder(Class<T> container) Create an InstanceIdentifierBuilder for a specific type of InstanceIdentifier as specified by container
static <T extends TreeNode> InstanceIdentifierBuilder<T>	builder(InstanceIdentifier<T> base) Deprecated. Use builder() instead.
<N extends TreeChildNode<? super T,?>> InstanceIdentifier<N>	child(Class<N> container)
<N extends TreeChildNode<? super T,?>,K> KeyedInstanceIdentifier<N,K>	child(Class<N> listItem, K listKey)
boolean	contains(InstanceIdentifier<? extends TreeNode> other) Check whether an identifier is contained in this identifier.
boolean	containsWildcarded(InstanceIdentifier<?> other) Check whether this instance identifier contains the other identifier after wildcard expansion.
static <T extends TreeNode> InstanceIdentifier<T>	create(Class<T> type) Create an instance identifier for a very specific object type.
static InstanceIdentifier<?>	create(Iterable<? extends TreeArgument> pathArguments) Create an instance identifier for a very specific object type.
boolean	equals(Object obj)
protected boolean	fastNonEqual(InstanceIdentifier<?> other) Perform class-specific fast checks for non-equality.
<I extends TreeNode> InstanceIdentifier<I>	firstIdentifierOf(Class<I> type) Return an instance identifier trimmed at the first occurrence of a specific component type.
<N extends TreeNode,K> K	firstKeyOf(Class<N> listItem) Return the key associated with the first component of specified type in an identifier.
<N extends TreeNode,K> K	firstKeyOf(Class<N> listItem, Class<K> listKey) Deprecated. Use firstKeyOf(Class) instead.
List<TreeArgument>	getPath() Deprecated. Use getPathArguments() instead.
Iterable<TreeArgument>	getPathArguments() Return the path argument chain which makes up this instance identifier.
Class<T>	getTargetType() Return the type of data which this InstanceIdentifier identifies.
int	hashCode()
boolean	isWildcarded() Check whether an instance identifier contains any wildcards.
static <N extends TreeNode,K> K	keyOf(InstanceIdentifier<N> id) Return the key associated with the last component of the specified identifier.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

pathArguments

protected final transient Iterable<TreeArgument> pathArguments

Method Detail

getTargetType

public final Class<T> getTargetType()

Return the type of data which this InstanceIdentifier identifies.

Returns:

Target type

getPathArguments

public final Iterable<TreeArgument> getPathArguments()

Return the path argument chain which makes up this instance identifier.

Returns:

Path argument chain. Immutable and does not contain nulls.

isWildcarded

public final boolean isWildcarded()

Check whether an instance identifier contains any wildcards. A wildcard is an path argument which has a null key.

Returns:

true if any of the path arguments has a null key.

hashCode

public final int hashCode()

Overrides:

hashCode in class Object

equals

public final boolean equals(Object obj)

Overrides:

equals in class Object

fastNonEqual

protected boolean fastNonEqual(InstanceIdentifier<?> other)

Perform class-specific fast checks for non-equality. This allows subclasses to avoid iterating over the pathArguments by performing quick checks on their specific fields.

Parameters:

other - The other identifier, guaranteed to be the same class

Returns:

true if the other identifier cannot be equal to this one.

toString

public final String toString()

Overrides:

toString in class Object

addToStringAttributes

protected com.google.common.base.MoreObjects.ToStringHelper addToStringAttributes(com.google.common.base.MoreObjects.ToStringHelper toStringHelper)

Add class-specific toString attributes.

Parameters:

toStringHelper - ToStringHelper instance

Returns:

ToStringHelper instance which was passed in

firstIdentifierOf

public final <I extends TreeNode> InstanceIdentifier<I> firstIdentifierOf(Class<I> type)

Return an instance identifier trimmed at the first occurrence of a specific component type. For example let's say an instance identifier was built like so,

      identifier = InstanceIdentifierBuilder.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId("openflow:1")).build();
 

And you wanted to obtain the Instance identifier which represented Nodes you would do it like so,

      identifier.firstIdentifierOf(Nodes.class)
 

Parameters:

type - component type

Returns:

trimmed instance identifier, or null if the component type is not present.

firstKeyOf

@Deprecated
public final <N extends TreeNode,K> K firstKeyOf(Class<N> listItem,
                                                             Class<K> listKey)

Deprecated. Use firstKeyOf(Class) instead.

Return the key associated with the first component of specified type in an identifier.

Parameters:

listItem - component type

listKey - component key type

Returns:

key associated with the component, or null if the component type is not present.

firstKeyOf

public final <N extends TreeNode,K> K firstKeyOf(Class<N> listItem)

Return the key associated with the first component of specified type in an identifier.

Parameters:

listItem - component type

Returns:

key associated with the component, or null if the component type is not present.

contains

public final boolean contains(InstanceIdentifier<? extends TreeNode> other)

Check whether an identifier is contained in this identifier. This is a strict subtree check, which requires all PathArguments to match exactly, e.g. The contains method checks if the other identifier is fully contained within the current identifier. It does this by looking at only the types of the path arguments and not by comparing the path arguments themselves. To illustrate here is an example which explains the working of this API. Let's say you have two instance identifiers as follows, this = /nodes/node/openflow:1 other = /nodes/node/openflow:2 then this.contains(other) will return false.

Specified by:

contains in interface org.opendaylight.yangtools.concepts.Path<InstanceIdentifier<? extends TreeNode>>

Parameters:

other -

Returns:

containsWildcarded

public final boolean containsWildcarded(InstanceIdentifier<?> other)

Check whether this instance identifier contains the other identifier after wildcard expansion. This is similar to contains(InstanceIdentifier), with the exception that a wildcards are assumed to match the their non-wildcarded PathArgument counterpart.

Parameters:

other - Identifier which should be checked for inclusion.

Returns:

true if this identifier contains the other object

builder

public InstanceIdentifierBuilder<T> builder()

Create a builder rooted at this key.

Returns:

A builder instance

child

public final <N extends TreeChildNode<? super T,?>> InstanceIdentifier<N> child(Class<N> container)

child

public final <N extends TreeChildNode<? super T,?>,K> KeyedInstanceIdentifier<N,K> child(Class<N> listItem,
                                                                                         K listKey)

augmentation

public final <N extends TreeNode & Augmentation<? super T>> InstanceIdentifier<N> augmentation(Class<N> container)

getPath

@Deprecated
public final List<TreeArgument> getPath()

Deprecated. Use getPathArguments() instead.

builder

@Deprecated
public static <T extends TreeNode> InstanceIdentifierBuilder<T> builder(InstanceIdentifier<T> base)

Deprecated. Use builder() instead.

Create a new InstanceIdentifierBuilder given a base InstanceIdentifier

Type Parameters:

T -

Parameters:

base -

Returns:

builder

public static <T extends TreeChildNode<? extends TreeRoot,?>> InstanceIdentifierBuilder<T> builder(Class<T> container)

Create an InstanceIdentifierBuilder for a specific type of InstanceIdentifier as specified by container

Type Parameters:

T -

Parameters:

container -

Returns:

builder

public static <N extends TreeChildNode<? extends TreeRoot,?>,K> InstanceIdentifierBuilder<N> builder(Class<N> listItem,
                                                                                                     K listKey)

Create an InstanceIdentifierBuilder for a specific type of InstanceIdentifier which represents an IdentifiableItem

Type Parameters:

N -

K -

Parameters:

listItem -

listKey -

Returns:

create

public static InstanceIdentifier<?> create(Iterable<? extends TreeArgument> pathArguments)

Create an instance identifier for a very specific object type. Example

  List<PathArgument> path = Arrays.asList(new Item(Nodes.class))
  new InstanceIdentifier(path);
 

Parameters:

pathArguments - The path to a specific node in the data tree

Returns:

InstanceIdentifier instance

Throws:

IllegalArgumentException - if pathArguments is empty or contains a null element.

create

public static <T extends TreeNode> InstanceIdentifier<T> create(Class<T> type)

Create an instance identifier for a very specific object type. For example

      new InstanceIdentifier(Nodes.class)
 

would create an InstanceIdentifier for an object of type Nodes

Parameters:

type - The type of the object which this instance identifier represents

Returns:

InstanceIdentifier instance

keyOf

public static <N extends TreeNode,K> K keyOf(InstanceIdentifier<N> id)

Return the key associated with the last component of the specified identifier.

Parameters:

id - instance identifier

Returns:

key associated with the last component

Throws:

IllegalArgumentException - if the supplied identifier type cannot have a key.

NullPointerException - if id is null.