X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=yang%2Fyang-data-api%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fapi%2FYangInstanceIdentifier.java;h=64ad1669b4595df41000f7df1735423660b3998d;hb=4eb9273dfe708426f7cb3c5746f40b522ef08534;hp=c882db6693bb9b2a9b97ecb31650f8d95c94004f;hpb=54d89c1479c4bcf63554076c4372b72e8c0c7444;p=yangtools.git diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifier.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifier.java index c882db6693..64ad1669b4 100644 --- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifier.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifier.java @@ -1,38 +1,49 @@ /* * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.yangtools.yang.data.api; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Verify.verify; +import static java.util.Objects.requireNonNull; + +import com.google.common.annotations.Beta; +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; -import com.google.common.collect.Lists; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; +import com.google.common.collect.Sets; +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; import java.io.Serializable; import java.lang.reflect.Array; -import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; +import java.util.Collection; +import java.util.Deque; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; +import java.util.Optional; import java.util.Set; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.concepts.Path; import org.opendaylight.yangtools.util.HashCodeBuilder; +import org.opendaylight.yangtools.util.ImmutableOffsetMap; +import org.opendaylight.yangtools.util.SharedSingletonMap; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; @@ -45,16 +56,18 @@ import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; * which conceptually is XPath expression minimized to uniquely identify element * in data tree which conforms to constraints maintained by YANG Model, * effectively this makes Instance Identifier a path to element in data tree. + * *

* Constraints put in YANG specification on instance-identifier allowed it to be * effectively represented in Java and it's evaluation does not require * full-blown XPath processor. + * *

*

Path Arguments

* Path to the node represented in instance identifier consists of * {@link PathArgument} which carries necessary information to uniquely identify * node on particular level in the subtree. - *

+ * *

* - * * @see RFC6020 */ -public final class YangInstanceIdentifier implements Path, Immutable, Serializable { - @SuppressWarnings("rawtypes") - private static final AtomicReferenceFieldUpdater LEGACYPATH_UPDATER = - AtomicReferenceFieldUpdater.newUpdater(YangInstanceIdentifier.class, ImmutableList.class, "legacyPath"); +// FIXME: 3.0.0: this concept needs to be moved to yang-common, as parser components need the ability to refer +// to data nodes -- most notably XPath expressions and {@code default} statement arguments need to be able +// to represent these. +// FIXME: FixedYangInstanceIdentifier needs YangInstanceIdentifier initialized, but that includes initializing +// this field. Figure out a way out of this pickle. +@SuppressFBWarnings("IC_SUPERCLASS_USES_SUBCLASS_DURING_INITIALIZATION") +public abstract class YangInstanceIdentifier implements Path, Immutable, Serializable { + /** + * An empty {@link YangInstanceIdentifier}. It corresponds to the path of the conceptual root of the YANG namespace. + */ + public static final YangInstanceIdentifier EMPTY = FixedYangInstanceIdentifier.EMPTY_INSTANCE; + private static final AtomicReferenceFieldUpdater TOSTRINGCACHE_UPDATER = AtomicReferenceFieldUpdater.newUpdater(YangInstanceIdentifier.class, String.class, "toStringCache"); - private static final YangInstanceIdentifier EMPTY = trustedCreate(Collections.emptyList()); - private static final Field PATHARGUMENTS_FIELD; + private static final long serialVersionUID = 4L; - private static final long serialVersionUID = 3L; - private transient final Iterable pathArguments; private final int hash; - - private volatile ImmutableList legacyPath = null; private transient volatile String toStringCache = null; - static { - final Field f; - try { - f = YangInstanceIdentifier.class.getDeclaredField("pathArguments"); - } catch (NoSuchFieldException | SecurityException e) { - throw new ExceptionInInitializerError(e); - } - f.setAccessible(true); - - PATHARGUMENTS_FIELD = f; + // Package-private to prevent outside subclassing + YangInstanceIdentifier(final int hash) { + this.hash = hash; } - private final ImmutableList getLegacyPath() { - // Temporary variable saves a volatile read - ImmutableList ret = legacyPath; - if (ret == null) { - // We could have used a synchronized block, but the window is quite - // small and worst that can happen is duplicate object construction. - ret = ImmutableList.copyOf(pathArguments); - LEGACYPATH_UPDATER.lazySet(this, ret); - } + @Nonnull abstract YangInstanceIdentifier createRelativeIdentifier(int skipFromRoot); - return ret; - } + @Nonnull abstract Collection tryPathArguments(); + + @Nonnull abstract Collection tryReversePathArguments(); /** - * Returns a list of path arguments. + * Check if this instance identifier has empty path arguments, e.g. it is + * empty and corresponds to {@link #EMPTY}. * - * @deprecated Use {@link #getPathArguments()} instead. - * @return Immutable list of path arguments. + * @return True if this instance identifier is empty, false otherwise. */ - @Deprecated - public List getPath() { - return getLegacyPath(); - } + public abstract boolean isEmpty(); + + /** + * Return an optimized version of this identifier, useful when the identifier + * will be used very frequently. + * + * @return A optimized equivalent instance. + */ + @Beta + public abstract YangInstanceIdentifier toOptimized(); + + /** + * Return the conceptual parent {@link YangInstanceIdentifier}, which has + * one item less in {@link #getPathArguments()}. + * + * @return Parent {@link YangInstanceIdentifier}, or null if this object is {@link #EMPTY}. + */ + @Nullable public abstract YangInstanceIdentifier getParent(); + + /** + * Return the ancestor {@link YangInstanceIdentifier} with a particular depth, e.g. number of path arguments. + * + * @param depth Ancestor depth + * @return Ancestor {@link YangInstanceIdentifier} + * @throws IllegalArgumentException if the specified depth is negative or is greater than the depth of this object. + */ + @Nonnull public abstract YangInstanceIdentifier getAncestor(int depth); /** * Returns an ordered iteration of path arguments. * * @return Immutable iteration of path arguments. */ - public Iterable getPathArguments() { - return pathArguments; - } + public abstract List getPathArguments(); /** * Returns an iterable of path arguments in reverse order. This is useful @@ -136,9 +158,7 @@ public final class YangInstanceIdentifier implements Path getReversePathArguments() { - return getLegacyPath().reverse(); - } + public abstract List getReversePathArguments(); /** * Returns the last PathArgument. This is equivalent of iterating @@ -146,47 +166,61 @@ public final class YangInstanceIdentifier implements Path path, final int hash) { - this.pathArguments = Preconditions.checkNotNull(path, "path must not be null."); - this.hash = hash; - } + public static YangInstanceIdentifier create(final Iterable path) { + if (Iterables.isEmpty(path)) { + return EMPTY; + } - private static final YangInstanceIdentifier trustedCreate(final Iterable path) { final HashCodeBuilder hash = new HashCodeBuilder<>(); for (PathArgument a : path) { hash.addArgument(a); } - return new YangInstanceIdentifier(path, hash.toInstance()); + return FixedYangInstanceIdentifier.create(path, hash.build()); } - public static final YangInstanceIdentifier create(final Iterable path) { - if (Iterables.isEmpty(path)) { - return EMPTY; - } + public static YangInstanceIdentifier create(final PathArgument... path) { + // We are forcing a copy, since we cannot trust the user + return create(Arrays.asList(path)); + } - return trustedCreate(ImmutableList.copyOf(path)); + /** + * Create a {@link YangInstanceIdentifier} by taking a snapshot of provided path and iterating it backwards. + * + * @param pathTowardsRoot Path towards root + * @return A {@link YangInstanceIdentifier} instance + * @throws NullPointerException if {@code pathTowardsRoot} or any of its members is null + */ + public static YangInstanceIdentifier createReverse(final Deque pathTowardsRoot) { + final ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize( + pathTowardsRoot.size()); + pathTowardsRoot.descendingIterator().forEachRemaining(builder::add); + return YangInstanceIdentifier.create(builder.build()); } - public static final YangInstanceIdentifier create(final PathArgument... path) { - // We are forcing a copy, since we cannot trust the user - return create(Arrays.asList(path)); + /** + * Create a {@link YangInstanceIdentifier} by walking specified stack backwards and extracting path components + * from it. + * + * @param stackTowardsRoot Stack towards root, + * @return A {@link YangInstanceIdentifier} instance + * @throws NullPointerException if {@code pathTowardsRoot} is null + */ + public static YangInstanceIdentifier createReverse(final Deque stackTowardsRoot, + final Function function) { + final ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize( + stackTowardsRoot.size()); + final Iterator it = stackTowardsRoot.descendingIterator(); + while (it.hasNext()) { + builder.add(function.apply(it.next())); + } + return YangInstanceIdentifier.create(builder.build()); } - @Override - public int hashCode() { - /* - * The caching is safe, since the object contract requires - * immutability of the object and all objects referenced from this - * object. - * Used lists, maps are immutable. Path Arguments (elements) are also - * immutable, since the PathArgument contract requires immutability. - */ - return hash; + boolean pathArgumentsEqual(final YangInstanceIdentifier other) { + return Iterables.elementsEqual(getPathArguments(), other.getPathArguments()); } @Override @@ -194,38 +228,35 @@ public final class YangInstanceIdentifier implements Path relativeTo(final YangInstanceIdentifier ancestor) { - final Iterator lit = pathArguments.iterator(); - final Iterator oit = ancestor.pathArguments.iterator(); + if (this == ancestor) { + return Optional.of(EMPTY); + } + if (ancestor.isEmpty()) { + return Optional.of(this); + } + + final Iterator lit = getPathArguments().iterator(); + final Iterator oit = ancestor.getPathArguments().iterator(); int common = 0; while (oit.hasNext()) { // Ancestor is not really an ancestor if (!lit.hasNext() || !lit.next().equals(oit.next())) { - return Optional.absent(); + return Optional.empty(); } ++common; @@ -257,7 +295,72 @@ public final class YangInstanceIdentifier implements Path lit = getPathArguments().iterator(); + final Iterator oit = other.getPathArguments().iterator(); + + while (lit.hasNext()) { + if (!oit.hasNext()) { + return false; + } + + if (!lit.next().equals(oit.next())) { + return false; + } + } + + return true; + } + + @Override + public final String toString() { + /* + * The toStringCache is safe, since the object contract requires + * immutability of the object and all objects referenced from this + * object. + * Used lists, maps are immutable. Path Arguments (elements) are also + * immutable, since the PathArgument contract requires immutability. + * The cache is thread-safe - if multiple computations occurs at the + * same time, cache will be overwritten with same result. + */ + String ret = toStringCache; + if (ret == null) { + final StringBuilder builder = new StringBuilder("/"); + PathArgument prev = null; + for (PathArgument argument : getPathArguments()) { + if (prev != null) { + builder.append('/'); + } + builder.append(argument.toRelativeString(prev)); + prev = argument; + } + + ret = builder.toString(); + TOSTRINGCACHE_UPDATER.lazySet(this, ret); + } + return ret; + } + + @Override + public final int hashCode() { + /* + * The caching is safe, since the object contract requires + * immutability of the object and all objects referenced from this + * object. + * Used lists, maps are immutable. Path Arguments (elements) are also + * immutable, since the PathArgument contract requires immutability. + */ + return hash; } private static int hashCode(final Object value) { @@ -265,7 +368,7 @@ public final class YangInstanceIdentifier implements Path * This interface itself is used as common parent for actual * path arguments types and should not be implemented by user code. + * *

* Path arguments SHOULD contain only minimum of information * required to uniquely identify node on particular subtree level. * + *

* For actual path arguments types see: *

    *
  • {@link NodeIdentifier} - Identifier of container or leaf @@ -341,6 +444,7 @@ public final class YangInstanceIdentifier implements Path * This method may return null, if the corresponding schema node, does * not have QName associated, such as in cases of augmentations. * @@ -360,15 +464,14 @@ public final class YangInstanceIdentifier implements Path HASH_UPDATER = - AtomicReferenceFieldUpdater.newUpdater(AbstractPathArgument.class, Integer.class, "hash"); + private abstract static class AbstractPathArgument implements PathArgument { private static final long serialVersionUID = -4546547994250849340L; private final QName nodeType; - private volatile transient Integer hash = null; + private transient int hashValue; + private transient volatile boolean hashGuard = false; protected AbstractPathArgument(final QName nodeType) { - this.nodeType = Preconditions.checkNotNull(nodeType); + this.nodeType = requireNonNull(nodeType); } @Override @@ -377,7 +480,8 @@ public final class YangInstanceIdentifier implements Path { - /** - * Adds {@link NodeIdentifier} with supplied QName to path arguments of resulting instance identifier. - * - * @param nodeType QName of {@link NodeIdentifier} which will be added - * @return this builder - */ - InstanceIdentifierBuilder node(QName nodeType); - - /** - * Adds {@link NodeIdentifierWithPredicates} with supplied QName and key values to path arguments of resulting instance identifier. - * - * @param nodeType QName of {@link NodeIdentifierWithPredicates} which will be added - * @param keyValues Map of key components and their respective values for {@link NodeIdentifierWithPredicates} - * @return this builder - */ - InstanceIdentifierBuilder nodeWithKey(QName nodeType, Map keyValues); - - /** - * Adds {@link NodeIdentifierWithPredicates} with supplied QName and key, value. - * - * @param nodeType QName of {@link NodeIdentifierWithPredicates} which will be added - * @param key QName of key which will be added - * @param value value of key which will be added - * @return this builder - */ - InstanceIdentifierBuilder nodeWithKey(QName nodeType, QName key, Object value); - - /** - * - * Builds an {@link YangInstanceIdentifier} with path arguments from this builder - * - * @return {@link YangInstanceIdentifier} - */ - YangInstanceIdentifier build(); - } - /** * Simple path argument identifying a {@link org.opendaylight.yangtools.yang.data.api.schema.ContainerNode} or * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode} leaf in particular subtree. */ public static final class NodeIdentifier extends AbstractPathArgument { private static final long serialVersionUID = -2255888212390871347L; + private static final LoadingCache CACHE = CacheBuilder.newBuilder().weakValues() + .build(new CacheLoader() { + @Override + public NodeIdentifier load(@Nonnull final QName key) { + return new NodeIdentifier(key); + } + }); public NodeIdentifier(final QName node) { super(node); } + + /** + * Return a NodeIdentifier for a particular QName. Unlike the constructor, this factory method uses a global + * instance cache, resulting in object reuse for equal inputs. + * + * @param node Node's QName + * @return A {@link NodeIdentifier} + */ + public static NodeIdentifier create(final QName node) { + return CACHE.getUnchecked(node); + } } /** @@ -491,13 +568,29 @@ public final class YangInstanceIdentifier implements Path keyValues; + public NodeIdentifierWithPredicates(final QName node) { + super(node); + this.keyValues = ImmutableMap.of(); + } + public NodeIdentifierWithPredicates(final QName node, final Map keyValues) { super(node); - this.keyValues = ImmutableMap.copyOf(keyValues); + // Retains ImmutableMap for empty maps. For larger sizes uses a shared key set. + this.keyValues = ImmutableOffsetMap.unorderedCopyOf(keyValues); + } + + public NodeIdentifierWithPredicates(final QName node, final ImmutableOffsetMap keyValues) { + super(node); + this.keyValues = requireNonNull(keyValues); + } + + public NodeIdentifierWithPredicates(final QName node, final SharedSingletonMap keyValues) { + super(node); + this.keyValues = requireNonNull(keyValues); } public NodeIdentifierWithPredicates(final QName node, final QName key, final Object value) { - this(node, ImmutableMap.of(key, value)); + this(node, SharedSingletonMap.unorderedOf(key, value)); } public Map getKeyValues() { @@ -517,12 +610,18 @@ public final class YangInstanceIdentifier implements Path otherKeyValues = ((NodeIdentifierWithPredicates) obj).keyValues; + + // TODO: benchmark to see if just calling equals() on the two maps is not faster + if (keyValues == otherKeyValues) { + return true; + } if (keyValues.size() != otherKeyValues.size()) { return false; } @@ -553,17 +652,17 @@ public final class YangInstanceIdentifier implements Path extends AbstractPathArgument { private static final long serialVersionUID = -3637456085341738431L; - private final Object value; + private final T value; - public NodeWithValue(final QName node, final Object value) { + public NodeWithValue(final QName node, final T value) { super(node); this.value = value; } - public Object getValue() { + public T getValue() { return value; } @@ -571,16 +670,17 @@ public final class YangInstanceIdentifier implements Path other = (NodeWithValue) obj; return Objects.deepEquals(value, other.value); } @@ -596,9 +696,10 @@ public final class YangInstanceIdentifier implements Path * Augmentation is uniquely identified by set of all possible child nodes. * This is possible * to identify instance of augmentation, @@ -606,7 +707,6 @@ public final class YangInstanceIdentifier implements PathRFC6020 */ public static final class AugmentationIdentifier implements PathArgument { @@ -620,9 +720,8 @@ public final class YangInstanceIdentifier implements Path otherIterator = otherChildNames.iterator(); - for (QName name : childNames) { - int c = name.compareTo(otherIterator.next()); - if (c != 0) { - return c; - } + // Quick Set-based comparison + if (childNames.equals(otherChildNames)) { + return 0; } - return 0; + + // We already know the sets are not equal, but have equal size, hence the sets differ in their elements, + // but potentially share a common set of elements. The most consistent way of comparing them is using + // total ordering defined by QName's compareTo. Hence convert both sets to lists ordered + // by QName.compareTo() and decide on the first differing element. + final List diff = new ArrayList<>(Sets.symmetricDifference(childNames, otherChildNames)); + verify(!diff.isEmpty(), "Augmentation identifiers %s and %s report no difference", this, o); + diff.sort(QName::compareTo); + return childNames.contains(diff.get(0)) ? -1 : 1; } else if (thisSize < otherSize) { return 1; } else { @@ -696,124 +799,74 @@ public final class YangInstanceIdentifier implements Path hash; - private final List path; - - public BuilderImpl() { - this.hash = new HashCodeBuilder<>(); - this.path = new ArrayList<>(); - } - - public BuilderImpl(final Iterable prefix, final int hash) { - this.path = Lists.newArrayList(prefix); - this.hash = new HashCodeBuilder<>(hash); - } - - @Override - public InstanceIdentifierBuilder node(final QName nodeType) { - final PathArgument arg = new NodeIdentifier(nodeType); - path.add(arg); - hash.addArgument(arg); - return this; - } - - @Override - public InstanceIdentifierBuilder nodeWithKey(final QName nodeType, final QName key, final Object value) { - final PathArgument arg = new NodeIdentifierWithPredicates(nodeType, key, value); - path.add(arg); - hash.addArgument(arg); - return this; - } - - @Override - public InstanceIdentifierBuilder nodeWithKey(final QName nodeType, final Map keyValues) { - final PathArgument arg = new NodeIdentifierWithPredicates(nodeType, keyValues); - path.add(arg); - hash.addArgument(arg); - return this; - } - - @Override - @Deprecated - public YangInstanceIdentifier toInstance() { - return build(); - } - - @Override - public YangInstanceIdentifier build() { - return new YangInstanceIdentifier(ImmutableList.copyOf(path), hash.toInstance()); - } - } - - @Override - public boolean contains(final YangInstanceIdentifier other) { - Preconditions.checkArgument(other != null, "other should not be null"); - - final Iterator lit = pathArguments.iterator(); - final Iterator oit = other.pathArguments.iterator(); - - while (lit.hasNext()) { - if (!oit.hasNext()) { - return false; - } - - if (!lit.next().equals(oit.next())) { - return false; - } - } + /** + * Fluent Builder of Instance Identifier instances. + */ + public interface InstanceIdentifierBuilder extends Builder { + /** + * Adds a {@link PathArgument} to path arguments of resulting instance identifier. + * + * @param arg A {@link PathArgument} to be added + * @return this builder + */ + InstanceIdentifierBuilder node(PathArgument arg); - return true; - } + /** + * Adds {@link NodeIdentifier} with supplied QName to path arguments of resulting instance identifier. + * + * @param nodeType QName of {@link NodeIdentifier} which will be added + * @return this builder + */ + InstanceIdentifierBuilder node(QName nodeType); - @Override - public String toString() { - /* - * The toStringCache is safe, since the object contract requires - * immutability of the object and all objects referenced from this - * object. - * Used lists, maps are immutable. Path Arguments (elements) are also - * immutable, since the PathArgument contract requires immutability. - * The cache is thread-safe - if multiple computations occurs at the - * same time, cache will be overwritten with same result. + /** + * Adds {@link NodeIdentifierWithPredicates} with supplied QName and key values to path arguments of resulting + * instance identifier. + * + * @param nodeType QName of {@link NodeIdentifierWithPredicates} which will be added + * @param keyValues Map of key components and their respective values for {@link NodeIdentifierWithPredicates} + * @return this builder */ - String ret = toStringCache; - if (ret == null) { - final StringBuilder builder = new StringBuilder("/"); - PathArgument prev = null; - for (PathArgument argument : getPathArguments()) { - if (prev != null) { - builder.append('/'); - } - builder.append(argument.toRelativeString(prev)); - prev = argument; - } + InstanceIdentifierBuilder nodeWithKey(QName nodeType, Map keyValues); - ret = builder.toString(); - TOSTRINGCACHE_UPDATER.lazySet(this, ret); - } - return ret; - } + /** + * Adds {@link NodeIdentifierWithPredicates} with supplied QName and key, value. + * + * @param nodeType QName of {@link NodeIdentifierWithPredicates} which will be added + * @param key QName of key which will be added + * @param value value of key which will be added + * @return this builder + */ + InstanceIdentifierBuilder nodeWithKey(QName nodeType, QName key, Object value); - private void readObject(final ObjectInputStream inputStream) throws IOException, ClassNotFoundException { - inputStream.defaultReadObject(); + /** + * Adds a collection of {@link PathArgument}s to path arguments of resulting instance identifier. + * + * @param args {@link PathArgument}s to be added + * @return this builder + * @throws NullPointerException if any of the arguments is null + */ + @Beta + InstanceIdentifierBuilder append(Collection args); - try { - PATHARGUMENTS_FIELD.set(this, legacyPath); - } catch (IllegalArgumentException | IllegalAccessException e) { - throw new IOException(e); + /** + * Adds a collection of {@link PathArgument}s to path arguments of resulting instance identifier. + * + * @param args {@link PathArgument}s to be added + * @return this builder + * @throws NullPointerException if any of the arguments is null + */ + @Beta + default InstanceIdentifierBuilder append(final PathArgument... args) { + return append(Arrays.asList(args)); } - } - private void writeObject(final ObjectOutputStream outputStream) throws IOException { - /* - * This may look strange, but what we are doing here is side-stepping the fact - * that pathArguments is not generally serializable. We are forcing instantiation - * of the legacy path, which is an ImmutableList (thus Serializable) and write - * it out. The read path does the opposite -- it reads the legacyPath and then - * uses invocation API to set the field. + /** + * Builds an {@link YangInstanceIdentifier} with path arguments from this builder. + * + * @return {@link YangInstanceIdentifier} */ - getLegacyPath(); - outputStream.defaultWriteObject(); + @Override + YangInstanceIdentifier build(); } }