From 633b8903e8f04899350224ea9a6a1ba51a580f71 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Mon, 28 Sep 2015 11:33:26 +0200 Subject: [PATCH] Introduce SchemaNodeIdentifier.asSchemaPath() Converting SchemaNodeIdentifier to a SchemaPath needs to be efficient, reuse the fact the two classes are organized in the same way. Change-Id: Ifa18f4378b66a94aa9f8e9d45fd274be9a517005 Signed-off-by: Robert Varga --- .../model/api/stmt/SchemaNodeIdentifier.java | 61 +++++++++++-------- .../yang/parser/stmt/rfc6020/Utils.java | 15 ++--- .../AugmentEffectiveStatementImpl.java | 12 +--- .../DeviationEffectiveStatementImpl.java | 3 +- .../effective/UsesEffectiveStatementImpl.java | 2 +- 5 files changed, 45 insertions(+), 48 deletions(-) diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SchemaNodeIdentifier.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SchemaNodeIdentifier.java index e4d9779741..7613aa1da4 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SchemaNodeIdentifier.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SchemaNodeIdentifier.java @@ -12,19 +12,18 @@ import com.google.common.base.MoreObjects.ToStringHelper; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; +import com.google.common.collect.UnmodifiableIterator; import java.util.Arrays; import java.util.Iterator; -import java.util.List; import java.util.NoSuchElementException; import java.util.Objects; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; /** - * Represents unique path to the every schema node inside the schema node identifier - * namespace. - * + * Represents unique path to the every schema node inside the schema node identifier namespace. */ public abstract class SchemaNodeIdentifier implements Immutable { @@ -43,7 +42,7 @@ public abstract class SchemaNodeIdentifier implements Immutable { @Override protected SchemaNodeIdentifier createInstance(final SchemaNodeIdentifier parent, final QName qname) { - return new Absolute(parent, qname); + return new Absolute(parent, Preconditions.checkNotNull(qname)); } } @@ -62,14 +61,15 @@ public abstract class SchemaNodeIdentifier implements Immutable { @Override protected SchemaNodeIdentifier createInstance(final SchemaNodeIdentifier parent, final QName qname) { - return new Relative(parent, qname); + return new Relative(parent, Preconditions.checkNotNull(qname)); } } @SuppressWarnings("rawtypes") private static final AtomicReferenceFieldUpdater LEGACYPATH_UPDATER = AtomicReferenceFieldUpdater.newUpdater(SchemaNodeIdentifier.class, ImmutableList.class, "legacyPath"); - + private static final AtomicReferenceFieldUpdater SCHEMAPATH_UPDATER = + AtomicReferenceFieldUpdater.newUpdater(SchemaNodeIdentifier.class, SchemaPath.class, "schemaPath"); /** * Shared instance of the conceptual root schema node. */ @@ -101,6 +101,11 @@ public abstract class SchemaNodeIdentifier implements Immutable { */ private volatile ImmutableList legacyPath; + /** + * Cached SchemaPath. + */ + private volatile SchemaPath schemaPath; + protected SchemaNodeIdentifier(final SchemaNodeIdentifier parent, final QName qname) { this.parent = parent; this.qname = qname; @@ -123,19 +128,6 @@ public abstract class SchemaNodeIdentifier implements Immutable { return ret; } - /** - * Returns the complete path to schema node. - * - * @return list of QName instances which represents complete - * path to schema node - * - * @deprecated Use {@link #getPathFromRoot()} instead. - */ - @Deprecated - public List getPath() { - return getLegacyPath(); - } - /** * Constructs new instance of this class with the concrete path. * @@ -248,7 +240,7 @@ public abstract class SchemaNodeIdentifier implements Immutable { return new Iterable() { @Override public Iterator iterator() { - return new Iterator() { + return new UnmodifiableIterator() { private SchemaNodeIdentifier current = SchemaNodeIdentifier.this; @Override @@ -266,11 +258,6 @@ public abstract class SchemaNodeIdentifier implements Immutable { throw new NoSuchElementException("No more elements available"); } } - - @Override - public void remove() { - throw new UnsupportedOperationException("Component removal not supported"); - } }; } }; @@ -294,6 +281,28 @@ public abstract class SchemaNodeIdentifier implements Immutable { return qname; } + private SchemaPath createSchemaPath() { + final SchemaPath newPath; + if (parent == null) { + final SchemaPath parentPath = isAbsolute() ? SchemaPath.ROOT : SchemaPath.SAME; + newPath = qname == null ? parentPath : parentPath.createChild(qname); + } else { + newPath = parent.asSchemaPath().createChild(qname); + } + + return SCHEMAPATH_UPDATER.compareAndSet(this, null, newPath) ? newPath : schemaPath; + } + + /** + * Create the {@link SchemaPath} equivalent of this identifier. + * + * @return SchemaPath equivalent. + */ + public final SchemaPath asSchemaPath() { + final SchemaPath ret = schemaPath; + return ret != null ? ret : createSchemaPath(); + } + /** * Describes whether schema node identifier is|isn't absolute. * diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java index 7c2a21e6a6..d8ed70f09b 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; import com.google.common.base.CharMatcher; +import com.google.common.base.Preconditions; import com.google.common.base.Splitter; import com.google.common.collect.Iterables; import java.util.ArrayList; @@ -406,9 +407,8 @@ public final class Utils { private static void addQNamesFromSchemaNodeIdentifierToList(final List qNamesFromRoot, final SchemaNodeIdentifier augmentTargetPath) { - Iterator augmentTargetPathIterator = augmentTargetPath.getPathFromRoot().iterator(); - while (augmentTargetPathIterator.hasNext()) { - qNamesFromRoot.add(augmentTargetPathIterator.next()); + for (QName qname : augmentTargetPath.getPathFromRoot()) { + qNamesFromRoot.add(qname); } } @@ -417,9 +417,8 @@ public final class Utils { // Yang constants should be lowercase so we have throw if value does not // suit this String deviateUpper = deviate.toUpperCase(); - if (Objects.equals(deviate, deviateUpper)) { - throw new IllegalArgumentException(String.format("String %s is not valid deviate argument", deviate)); - } + Preconditions.checkArgument(!Objects.equals(deviate, deviateUpper), + "String %s is not valid deviate argument", deviate); // but Java enum is uppercase so we cannot use lowercase here try { @@ -449,10 +448,6 @@ public final class Utils { return status; } - public static SchemaPath SchemaNodeIdentifierToSchemaPath(final SchemaNodeIdentifier identifier) { - return SchemaPath.create(identifier.getPathFromRoot(), identifier.isAbsolute()); - } - public static Date getLatestRevision(final RootStatementContext root) { return getLatestRevision(root.declaredSubstatements()); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java index 365c461fdb..366c6acca1 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java @@ -32,8 +32,7 @@ import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils; public class AugmentEffectiveStatementImpl - extends - AbstractEffectiveDocumentedDataNodeContainer + extends AbstractEffectiveDocumentedDataNodeContainer implements AugmentationSchema, NamespaceRevisionAware, Comparable { private final SchemaPath targetPath; private final URI namespace; @@ -47,11 +46,7 @@ public class AugmentEffectiveStatementImpl final StmtContext> ctx) { super(ctx); - SchemaNodeIdentifier schemaNodeIdentifier = ctx.getStatementArgument(); - this.targetPath = SchemaPath.create( - schemaNodeIdentifier.getPathFromRoot(), - schemaNodeIdentifier.isAbsolute()); - + this.targetPath = ctx.getStatementArgument().asSchemaPath(); QNameModule rootModuleQName = Utils.getRootModuleQName(ctx); this.namespace = rootModuleQName.getNamespace(); this.revision = rootModuleQName.getRevision(); @@ -161,8 +156,7 @@ public class AugmentEffectiveStatementImpl @Override public String toString() { - StringBuilder sb = new StringBuilder( - AugmentEffectiveStatementImpl.class.getSimpleName()); + StringBuilder sb = new StringBuilder(AugmentEffectiveStatementImpl.class.getSimpleName()); sb.append("["); sb.append("targetPath=").append(targetPath); sb.append(", when=").append(whenCondition); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java index 2b439a13e9..3b3a9ed948 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java @@ -33,8 +33,7 @@ public class DeviationEffectiveStatementImpl extends EffectiveStatementBase unknownSchemaNodesInit = new LinkedList<>(); - targetPath = SchemaPath.create(ctx.getStatementArgument().getPathFromRoot(), ctx.getStatementArgument() - .isAbsolute()); + targetPath = ctx.getStatementArgument().asSchemaPath(); for (final EffectiveStatement effectiveStatement : effectiveSubstatements()) { if (effectiveStatement instanceof DeviateEffectiveStatementImpl) { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java index 0a95b20312..f506bd091c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java @@ -73,7 +73,7 @@ public class UsesEffectiveStatementImpl extends EffectiveStatementBase