BUG-4556: Introduce StmtContext.getSchemaPath()

SchemaContexts are created in top-to-bottom direction, making them
useful for holding SchemaPaths. This reduces the memory overhead
from not constructing SchemaPaths in a hierarchical manner.

Change-Id: I85a49c6c861543a585730c8dac12622605eb20d5
Signed-off-by: Robert Varga <robert.varga@pantheon.sk>

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java
index ee6007ee292fb264344328c2d3e33bec471d8f9f..a762d7fc39dce6bc662d2337cf728509dab7de4f 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java
@@ -7,20 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.spi.meta;
 
+import com.google.common.base.Optional;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import java.util.Collection;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
 import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
 
 public interface StmtContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> {
 
@@ -42,10 +44,13 @@ public interface StmtContext<A, D extends DeclaredStatement<A>, E extends Effect
     @Nullable
     A getStatementArgument();
 
-    @Nullable
-    List<Object> getArgumentsFromRoot();
-
-    List<StmtContext<?,?,?>> getStmtContextsFromRoot();
+    /**
+     * Return the {@link SchemaPath} of this statement. Not all statements have a SchemaPath, in which case
+     * {@link Optional#absent()} is returned.
+     *
+     * @return Optional SchemaPath
+     */
+    @Nonnull Optional<SchemaPath> getSchemaPath();
 
     @Nonnull
     <K, V, KT extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java
index b1bf364e0c387792d4b156d333ce25aa1dd387a0..ee47e07753c6cec5a57478536346caacf8b5acc9 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java
@@ -7,10 +7,10 @@
  */
 package org.opendaylight.yangtools.yang.parser.stmt.reactor;
 
+import com.google.common.base.Optional;
 import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
 import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
@@ -28,13 +28,13 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
     private final SourceSpecificContext sourceContext;
     private final A argument;
 
-    RootStatementContext(ContextBuilder<A, D, E> builder, SourceSpecificContext sourceContext) throws SourceException {
+    RootStatementContext(final ContextBuilder<A, D, E> builder, final SourceSpecificContext sourceContext) throws SourceException {
         super(builder);
         this.sourceContext = sourceContext;
         this.argument = builder.getDefinition().parseArgumentValue(this, builder.getRawArgument());
     }
 
-    RootStatementContext(RootStatementContext<A, D, E> original, QNameModule newQNameModule, TypeOfCopy typeOfCopy)
+    RootStatementContext(final RootStatementContext<A, D, E> original, final QNameModule newQNameModule, final TypeOfCopy typeOfCopy)
             throws SourceException {
         super(original);
 
@@ -54,8 +54,8 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
      *            determines whether copy is used by augmentation or uses
      * @throws SourceException
      */
-    private void copyDeclaredStmts(RootStatementContext<A, D, E> original, QNameModule newQNameModule,
-            TypeOfCopy typeOfCopy) throws SourceException {
+    private void copyDeclaredStmts(final RootStatementContext<A, D, E> original, final QNameModule newQNameModule,
+            final TypeOfCopy typeOfCopy) throws SourceException {
         Collection<? extends StmtContext<?, ?, ?>> originalDeclaredSubstatements = original.declaredSubstatements();
         for (StmtContext<?, ?, ?> stmtContext : originalDeclaredSubstatements) {
             this.addEffectiveSubstatement(stmtContext.createCopy(newQNameModule, this, typeOfCopy));
@@ -69,8 +69,8 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
      *            determines whether copy is used by augmentation or uses
      * @throws SourceException
      */
-    private void copyEffectiveStmts(RootStatementContext<A, D, E> original, QNameModule newQNameModule,
-            TypeOfCopy typeOfCopy) throws SourceException {
+    private void copyEffectiveStmts(final RootStatementContext<A, D, E> original, final QNameModule newQNameModule,
+            final TypeOfCopy typeOfCopy) throws SourceException {
         Collection<? extends StmtContext<?, ?, ?>> originalEffectiveSubstatements = original.effectiveSubstatements();
         for (StmtContext<?, ?, ?> stmtContext : originalEffectiveSubstatements) {
             this.addEffectiveSubstatement(stmtContext.createCopy(newQNameModule, this, typeOfCopy));
@@ -128,7 +128,7 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
      * @throws SourceException instance of SourceException
      */
     @Override
-    public StatementContextBase<?, ?, ?> createCopy(StatementContextBase<?, ?, ?> newParent, TypeOfCopy typeOfCopy)
+    public StatementContextBase<?, ?, ?> createCopy(final StatementContextBase<?, ?, ?> newParent, final TypeOfCopy typeOfCopy)
             throws SourceException {
         return createCopy(null, newParent, typeOfCopy);
     }
@@ -139,8 +139,8 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
      * @throws SourceException instance of SourceException
      */
     @Override
-    public StatementContextBase<A, D, E> createCopy(QNameModule newQNameModule,
-            StatementContextBase<?, ?, ?> newParent, TypeOfCopy typeOfCopy) throws SourceException {
+    public StatementContextBase<A, D, E> createCopy(final QNameModule newQNameModule,
+            final StatementContextBase<?, ?, ?> newParent, final TypeOfCopy typeOfCopy) throws SourceException {
         RootStatementContext<A, D, E> copy = new RootStatementContext<>(this, newQNameModule, typeOfCopy);
 
         copy.addAllToCopyHistory(this.getCopyHistory());
@@ -155,24 +155,9 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
         return copy;
     }
 
-    /**
-     * @return this' argument as it is the only from root (this)
-     */
-    @Override
-    public List<Object> getArgumentsFromRoot() {
-        List<Object> argumentList = new LinkedList<>();
-        argumentList.add(argument);
-        return argumentList;
-    }
-
-    /**
-     * @return this as it is the only\context from root (this)
-     */
     @Override
-    public List<StmtContext<?, ?, ?>> getStmtContextsFromRoot() {
-        List<StmtContext<?, ?, ?>> stmtContextsList = new LinkedList<>();
-        stmtContextsList.add(this);
-        return stmtContextsList;
+    public Optional<SchemaPath> getSchemaPath() {
+        return Optional.of(SchemaPath.ROOT);
     }
 
     /**
@@ -182,5 +167,4 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
     public boolean isRootContext() {
         return true;
     }
-
 }

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java
index 04a01d17fceaebb6b1b913c071519724ea8cb489..6e2f652a065d172d72a21d9b55a4ff17cbb8a685 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java
@@ -7,54 +7,58 @@
  */
 package org.opendaylight.yangtools.yang.parser.stmt.reactor;
 
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import java.util.List;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.GroupingUtils;
-import org.opendaylight.yangtools.yang.common.QNameModule;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Verify;
 import java.util.Collection;
 import org.opendaylight.yangtools.yang.common.QName;
-import com.google.common.base.Preconditions;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.GroupingUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
-class SubstatementContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
+final class SubstatementContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
         extends StatementContextBase<A, D, E> {
 
     private final StatementContextBase<?, ?, ?> parent;
     private final A argument;
+    private volatile SchemaPath schemaPath;
 
-    SubstatementContext(StatementContextBase<?, ?, ?> parent,
-            ContextBuilder<A, D, E> builder) throws SourceException {
+    SubstatementContext(final StatementContextBase<?, ?, ?> parent,
+            final ContextBuilder<A, D, E> builder) throws SourceException {
         super(builder);
-        this.parent = Preconditions.checkNotNull(parent,
-                "Parent must not be null");
-        this.argument = builder.getDefinition().parseArgumentValue(this,
-                builder.getRawArgument());
+        this.parent = Preconditions.checkNotNull(parent, "Parent must not be null");
+        this.argument = builder.getDefinition().parseArgumentValue(this, builder.getRawArgument());
     }
 
     @SuppressWarnings("unchecked")
-    SubstatementContext(SubstatementContext<A, D, E> original,
-            QNameModule newQNameModule,
-            StatementContextBase<?, ?, ?> newParent, TypeOfCopy typeOfCopy)
-            throws SourceException {
+    SubstatementContext(final SubstatementContext<A, D, E> original,
+            final QNameModule newQNameModule,
+            final StatementContextBase<?, ?, ?> newParent, final TypeOfCopy typeOfCopy) {
         super(original);
         this.parent = newParent;
 
         if (newQNameModule != null) {
             if (original.argument instanceof QName) {
                 QName originalQName = (QName) original.argument;
-                this.argument = (A) QName.create(newQNameModule,
-                        originalQName.getLocalName());
-            } else if (StmtContextUtils.producesDeclared(original,
-                    KeyStatement.class)) {
-                this.argument = (A) StmtContextUtils
-                        .replaceModuleQNameForKey(
+                this.argument = (A) QName.create(newQNameModule, originalQName.getLocalName());
+            } else if (StmtContextUtils.producesDeclared(original, KeyStatement.class)) {
+                this.argument = (A) StmtContextUtils.replaceModuleQNameForKey(
                                 (StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?>) original,
                                 newQNameModule);
             } else {
@@ -65,8 +69,9 @@ class SubstatementContext<A, D extends DeclaredStatement<A>, E extends Effective
         }
     }
 
-    private void copyDeclaredStmts(SubstatementContext<A, D, E> original,
-            QNameModule newQNameModule, TypeOfCopy typeOfCopy)
+
+    private void copyDeclaredStmts(final SubstatementContext<A, D, E> original,
+            final QNameModule newQNameModule, final TypeOfCopy typeOfCopy)
             throws SourceException {
         Collection<? extends StatementContextBase<?, ?, ?>> originalDeclaredSubstatements = original
                 .declaredSubstatements();
@@ -81,8 +86,8 @@ class SubstatementContext<A, D extends DeclaredStatement<A>, E extends Effective
         }
     }
 
-    private void copyEffectiveStmts(SubstatementContext<A, D, E> original,
-            QNameModule newQNameModule, TypeOfCopy typeOfCopy)
+    private void copyEffectiveStmts(final SubstatementContext<A, D, E> original,
+            final QNameModule newQNameModule, final TypeOfCopy typeOfCopy)
             throws SourceException {
         Collection<? extends StatementContextBase<?, ?, ?>> originalEffectiveSubstatements = original
                 .effectiveSubstatements();
@@ -124,17 +129,16 @@ class SubstatementContext<A, D extends DeclaredStatement<A>, E extends Effective
 
     @Override
     public StatementContextBase<?, ?, ?> createCopy(
-            StatementContextBase<?, ?, ?> newParent, TypeOfCopy typeOfCopy)
+            final StatementContextBase<?, ?, ?> newParent, final TypeOfCopy typeOfCopy)
             throws SourceException {
         return createCopy(null, newParent, typeOfCopy);
     }
 
     @Override
-    public StatementContextBase<A, D, E> createCopy(QNameModule newQNameModule,
-            StatementContextBase<?, ?, ?> newParent, TypeOfCopy typeOfCopy)
+    public StatementContextBase<A, D, E> createCopy(final QNameModule newQNameModule,
+            final StatementContextBase<?, ?, ?> newParent, final TypeOfCopy typeOfCopy)
             throws SourceException {
-        SubstatementContext<A, D, E> copy = new SubstatementContext<>(this,
-                newQNameModule, newParent, typeOfCopy);
+        SubstatementContext<A, D, E> copy = new SubstatementContext<>(this, newQNameModule, newParent, typeOfCopy);
 
         copy.addAllToCopyHistory(this.getCopyHistory());
         copy.addToCopyHistory(typeOfCopy);
@@ -152,19 +156,68 @@ class SubstatementContext<A, D extends DeclaredStatement<A>, E extends Effective
         return copy;
     }
 
-    @Override
-    public List<Object> getArgumentsFromRoot() {
-        List<Object> argumentsFromRoot = parent.getArgumentsFromRoot();
-        argumentsFromRoot.add(argument);
-        return argumentsFromRoot;
+    private boolean isSupportedAsShorthandCase() {
+        final Collection<?> supportedCaseShorthands = getFromNamespace(ValidationBundlesNamespace.class,
+                ValidationBundleType.SUPPORTED_CASE_SHORTHANDS);
+        return supportedCaseShorthands == null || supportedCaseShorthands.contains(getPublicDefinition());
+    }
+
+    private SchemaPath createSchemaPath() {
+        final Optional<SchemaPath> maybeParentPath = parent.getSchemaPath();
+        Verify.verify(maybeParentPath.isPresent(), "Parent %s does not have a SchemaPath", parent);
+        final SchemaPath parentPath = maybeParentPath.get();
+
+        if (argument instanceof QName) {
+            QName qname = (QName) argument;
+            if (StmtContextUtils.producesDeclared(this, UsesStatement.class)) {
+                return maybeParentPath.orNull();
+            }
+
+            final SchemaPath path;
+            if (StmtContextUtils.producesDeclared(getParentContext(), ChoiceStatement.class)
+                    && isSupportedAsShorthandCase()) {
+                path = parentPath.createChild(qname);
+            } else {
+                path = parentPath;
+            }
+            return path.createChild(qname);
+        }
+        if (argument instanceof String) {
+            // FIXME: This may yield illegal argument exceptions
+            final StatementContextBase<?, ?, ?> originalCtx = getOriginalCtx();
+            final QName qname = (originalCtx != null) ? Utils.qNameFromArgument(originalCtx, (String) argument)
+                    : Utils.qNameFromArgument(this, (String) argument);
+            return parentPath.createChild(qname);
+        }
+        if (argument instanceof SchemaNodeIdentifier &&
+                (StmtContextUtils.producesDeclared(this, AugmentStatement.class)
+                   || StmtContextUtils.producesDeclared(this, RefineStatement.class))) {
+
+            return parentPath.createChild(((SchemaNodeIdentifier) argument).getPathFromRoot());
+        }
+        if (Utils.isUnknownNode(this)) {
+            return parentPath.createChild(getPublicDefinition().getStatementName());
+        }
+
+        // FIXME: this does not look right
+        return maybeParentPath.orNull();
     }
 
     @Override
-    public List<StmtContext<?, ?, ?>> getStmtContextsFromRoot() {
-        List<StmtContext<?, ?, ?>> stmtContextsList = parent
-                .getStmtContextsFromRoot();
-        stmtContextsList.add(this);
-        return stmtContextsList;
+    public Optional<SchemaPath> getSchemaPath() {
+        SchemaPath local = schemaPath;
+        if (local == null) {
+            synchronized (this) {
+                local = schemaPath;
+                if (local == null) {
+                    local = createSchemaPath();
+                    schemaPath = local;
+                }
+            }
+
+        }
+
+        return Optional.fromNullable(local);
     }
 
     @Override

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 806857fabfa3e04637cbe79ff997bbd9cb14695a..b4a420d14c2fbaea30054441c8e8852c03271b04 100644 (file)
--- 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
@@ -18,8 +18,6 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Date;
 import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
@@ -37,18 +35,13 @@ import org.opendaylight.yangtools.yang.common.YangConstants;
 import org.opendaylight.yangtools.yang.model.api.Deviation;
 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
@@ -59,15 +52,12 @@ import org.opendaylight.yangtools.yang.parser.spi.source.ModuleIdentifierToModul
 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToModuleQName;
 import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
 import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
 import org.opendaylight.yangtools.yang.parser.stmt.reactor.RootStatementContext;
 import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public final class Utils {
-
     private static final Logger LOG = LoggerFactory.getLogger(Utils.class);
     private static final CharMatcher DOUBLE_QUOTE_MATCHER = CharMatcher.is('"');
     private static final CharMatcher SINGLE_QUOTE_MATCHER = CharMatcher.is('\'');
@@ -300,75 +290,11 @@ public final class Utils {
         return (StatementContextBase<?, ?, ?>) rootStmtCtx.getFromNamespace(SchemaNodeIdentifierBuildNamespace.class, node);
     }
 
-    public static SchemaPath getSchemaPath(final StmtContext<?, ?, ?> ctx) {
-
-        if (ctx == null) {
-            return null;
-        }
-
-        final Iterator<StmtContext<?, ?, ?>> iteratorFromRoot = ctx.getStmtContextsFromRoot().iterator();
-        // skip root argument
-        if (iteratorFromRoot.hasNext()) {
-            iteratorFromRoot.next();
-        }
-
-        List<QName> qNamesFromRoot = new LinkedList<>();
-        while (iteratorFromRoot.hasNext()) {
-            StmtContext<?, ?, ?> nextStmtCtx = iteratorFromRoot.next();
-            Object nextStmtArgument = nextStmtCtx.getStatementArgument();
-            if (nextStmtArgument instanceof QName) {
-                QName qname = (QName) nextStmtArgument;
-                if (StmtContextUtils.producesDeclared(nextStmtCtx, UsesStatement.class)) {
-                    continue;
-                }
-                if (StmtContextUtils.producesDeclared(nextStmtCtx.getParentContext(), ChoiceStatement.class)
-                        && isSupportedAsShorthandCase(nextStmtCtx)) {
-                    qNamesFromRoot.add(qname);
-                }
-                qNamesFromRoot.add(qname);
-            } else if (nextStmtArgument instanceof String) {
-                // FIXME: This may yield illegal argument exceptions
-                StatementContextBase<?, ?, ?> originalCtx = ctx
-                        .getOriginalCtx();
-                final QName qName = (originalCtx != null) ? qNameFromArgument(
-                        originalCtx, (String) nextStmtArgument)
-                        : qNameFromArgument(ctx, (String) nextStmtArgument);
-                qNamesFromRoot.add(qName);
-            } else if ((StmtContextUtils.producesDeclared(nextStmtCtx, AugmentStatement.class)
-                       || StmtContextUtils.producesDeclared(nextStmtCtx, RefineStatement.class))
-                    && nextStmtArgument instanceof SchemaNodeIdentifier) {
-                addQNamesFromSchemaNodeIdentifierToList(qNamesFromRoot, (SchemaNodeIdentifier) nextStmtArgument);
-            } else if (isUnknownNode(nextStmtCtx)) {
-                qNamesFromRoot.add(nextStmtCtx.getPublicDefinition().getStatementName());
-            } else {
-                return SchemaPath.SAME;
-            }
-        }
-
-        final SchemaPath schemaPath = SchemaPath.create(qNamesFromRoot, true);
-        return schemaPath;
-    }
-
     public static boolean isUnknownNode(final StmtContext<?, ?, ?> stmtCtx) {
         return stmtCtx.getPublicDefinition().getDeclaredRepresentationClass()
                 .isAssignableFrom(UnknownStatementImpl.class);
     }
 
-    private static boolean isSupportedAsShorthandCase(final StmtContext<?, ?, ?> statementCtx) {
-
-        Collection<?> supportedCaseShorthands = statementCtx.getFromNamespace(ValidationBundlesNamespace.class,
-                ValidationBundleType.SUPPORTED_CASE_SHORTHANDS);
-
-        return supportedCaseShorthands == null || supportedCaseShorthands.contains(statementCtx.getPublicDefinition());
-    }
-
-    private static void addQNamesFromSchemaNodeIdentifierToList(final List<QName> qNamesFromRoot,
-            final SchemaNodeIdentifier augmentTargetPath) {
-        for (QName qname : augmentTargetPath.getPathFromRoot()) {
-            qNamesFromRoot.add(qname);
-        }
-    }
-
     public static Deviation.Deviate parseDeviateFromString(final String deviate) {
 
         // Yang constants should be lowercase so we have throw if value does not

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSchemaNode.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSchemaNode.java
index 46bbfd426b4034b64051cea2cf710cb957734c39..9c56461db6728815d663940f8037ff63aae889a6 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSchemaNode.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSchemaNode.java
@@ -17,7 +17,6 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 abstract class AbstractEffectiveSchemaNode<D extends DeclaredStatement<QName>> extends
         AbstractEffectiveDocumentedNode<QName, D> implements SchemaNode {
@@ -26,10 +25,10 @@ abstract class AbstractEffectiveSchemaNode<D extends DeclaredStatement<QName>> e
     private final SchemaPath path;
     private final List<UnknownSchemaNode> unknownNodes;
 
-    AbstractEffectiveSchemaNode(StmtContext<QName, D, ?> ctx) {
+    AbstractEffectiveSchemaNode(final StmtContext<QName, D, ?> ctx) {
         super(ctx);
         this.qname = ctx.getStatementArgument();
-        this.path = Utils.getSchemaPath(ctx);
+        this.path = ctx.getSchemaPath().get();
 
         Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
         ImmutableList.Builder<UnknownSchemaNode> listBuilder = new ImmutableList.Builder<>();

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSimpleDataNodeContainer.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSimpleDataNodeContainer.java
index cc99f07f043b4cb90098889ac307bada38385308..7503af7e193a505bd507e1f85af6ad3b45e00c28 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSimpleDataNodeContainer.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveSimpleDataNodeContainer.java
@@ -26,7 +26,6 @@ import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 abstract class AbstractEffectiveSimpleDataNodeContainer<D extends DeclaredStatement<QName>> extends
         AbstractEffectiveDocumentedDataNodeContainer<QName, D> implements DataNodeContainer, AugmentationTarget,
@@ -44,11 +43,11 @@ abstract class AbstractEffectiveSimpleDataNodeContainer<D extends DeclaredStatem
     private final Set<AugmentationSchema> augmentations;
     private final List<UnknownSchemaNode> unknownNodes;
 
-    public AbstractEffectiveSimpleDataNodeContainer(StmtContext<QName, D, ?> ctx) {
+    public AbstractEffectiveSimpleDataNodeContainer(final StmtContext<QName, D, ?> ctx) {
         super(ctx);
 
         this.qname = ctx.getStatementArgument();
-        this.path = Utils.getSchemaPath(ctx);
+        this.path = ctx.getSchemaPath().get();
         this.constraints = new EffectiveConstraintDefinitionImpl(this);
 
         ConfigEffectiveStatementImpl configStmt = firstEffective(ConfigEffectiveStatementImpl.class);

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtendedTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtendedTypeEffectiveStatementImpl.java
index fe0ccae5aaca3304df7f4eb129ce99d14468e673..912ffc99ae12d1e62bba1496d40afdb2e7f8fdeb 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtendedTypeEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtendedTypeEffectiveStatementImpl.java
@@ -69,9 +69,9 @@ implements
         final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> typeStmt =
                 ctx.getFromNamespace(TypeNamespace.class, qName);
         if (typeStmt == null) {
-            path = Utils.getSchemaPath(ctx);
+            path = ctx.getSchemaPath().get();
         } else {
-            path = Utils.getSchemaPath(ctx.getFromNamespace(TypeNamespace.class, qName));
+            path = ctx.getFromNamespace(TypeNamespace.class, qName).getSchemaPath().get();
         }
 
         UnitsEffectiveStatementImpl unitsStmt = firstEffective(UnitsEffectiveStatementImpl.class);

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java
index 46e32b3eada53ac9dcaab6b0876801a774a7c2db..ea51f04f30dcee85e66c8d6d9c67bbc1961b6736 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java
@@ -19,7 +19,6 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 public class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, ExtensionStatement>
         implements ExtensionDefinition {
@@ -34,7 +33,7 @@ public class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumented
             final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> ctx) {
         super(ctx);
         this.qname = ctx.getStatementArgument();
-        this.schemaPath = Utils.getSchemaPath(ctx);
+        this.schemaPath = ctx.getSchemaPath().get();
 
         // initSubstatementCollections
         Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/GroupingEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/GroupingEffectiveStatementImpl.java
index 25696438a39938d00ff6e5caebdb9bf67eafc0a2..7f0275d600cea71a2f2ed7477e42ceb57f63f4dc 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/GroupingEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/GroupingEffectiveStatementImpl.java
@@ -20,7 +20,6 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 public class GroupingEffectiveStatementImpl extends
         AbstractEffectiveDocumentedDataNodeContainer<QName, GroupingStatement> implements GroupingDefinition {
@@ -34,7 +33,7 @@ public class GroupingEffectiveStatementImpl extends
         super(ctx);
 
         qname = ctx.getStatementArgument();
-        path = Utils.getSchemaPath(ctx);
+        path = ctx.getSchemaPath().get();
 
         // initCopyType
         List<TypeOfCopy> copyTypesFromOriginal = ctx.getCopyHistory();

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/NotificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/NotificationEffectiveStatementImpl.java
index 849ae138f400c9f1649ac5c8b7dfe5da4b088379..67e46139c857b7ecda7fe63f6895ddbfaf626dcd 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/NotificationEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/NotificationEffectiveStatementImpl.java
@@ -23,7 +23,6 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 public class NotificationEffectiveStatementImpl extends
         AbstractEffectiveDocumentedDataNodeContainer<QName, NotificationStatement> implements NotificationDefinition {
@@ -36,7 +35,7 @@ public class NotificationEffectiveStatementImpl extends
             final StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
         super(ctx);
         this.qname = ctx.getStatementArgument();
-        this.path = Utils.getSchemaPath(ctx);
+        this.path = ctx.getSchemaPath().get();
 
         // initSubstatementCollections
         Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RefineEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RefineEffectiveStatementImpl.java
index ebef3fd511791d4ac6e7f6bbfaf444172cb148b9..34bad08f45a3104baaa8680576f64a014e842b66 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RefineEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RefineEffectiveStatementImpl.java
@@ -19,7 +19,6 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 public final class RefineEffectiveStatementImpl extends
         AbstractEffectiveDocumentedNode<SchemaNodeIdentifier, RefineStatement> implements SchemaNode {
@@ -32,7 +31,7 @@ public final class RefineEffectiveStatementImpl extends
     public RefineEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
         super(ctx);
         qname = ctx.getStatementArgument().getLastComponent();
-        path = Utils.getSchemaPath(ctx);
+        path = ctx.getSchemaPath().get();
         refineTargetNode = (SchemaNode) ctx.getEffectOfStatement().iterator().next().buildEffective();
 
         // initSubstatementCollectionsAndFields

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UnknownEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UnknownEffectiveStatementImpl.java
index fe20cdb8d51f8d9e588dceb00678e718ede6ccc7..8ce35406c707d251cf755768213ceaea83ddd87f 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UnknownEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UnknownEffectiveStatementImpl.java
@@ -72,7 +72,7 @@ public final class UnknownEffectiveStatementImpl extends AbstractEffectiveDocume
             }
             this.maybeQNameArgument = maybeQNameArgumentInit;
         }
-        path = Utils.getSchemaPath(ctx.getParentContext()).createChild(maybeQNameArgument);
+        path = ctx.getParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
         nodeParameter = (ctx.rawStatementArgument() == null) ? "" : ctx.rawStatementArgument();
 
         // TODO init other fields (see Bug1412Test)

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 421c11153c541bb3a08ef0f3f296ab8eb0d28988..7571f49f33588bab1bd0d79a5546d587b6135519 100644 (file)
--- 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
@@ -31,7 +31,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 
 public final class UsesEffectiveStatementImpl extends EffectiveStatementBase<QName, UsesStatement> implements UsesNode {
     private final SchemaPath groupingPath;
@@ -47,7 +46,7 @@ public final class UsesEffectiveStatementImpl extends EffectiveStatementBase<QNa
         // initGroupingPath
         StmtContext<?, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> grpCtx = ctx.getFromNamespace(
                 GroupingNamespace.class, ctx.getStatementArgument());
-        this.groupingPath = Utils.getSchemaPath(grpCtx);
+        this.groupingPath = grpCtx.getSchemaPath().get();
 
         // initCopyType
         List<TypeOfCopy> copyTypesFromOriginal = ctx.getCopyHistory();

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java
index a471895f924de7d937af48392c2a89dd4e00291e..7493a6146932e0b2aa12cca643b10716c112945b 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java
@@ -19,7 +19,6 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PositionEffectiveStatementImpl;
@@ -43,7 +42,7 @@ public class BitEffectiveStatementImpl extends EffectiveStatementBase<QName, Bit
         List<UnknownSchemaNode> unknownSchemaNodesInit = new ArrayList<>();
 
         qName = ctx.getStatementArgument();
-        schemaPath = Utils.getSchemaPath(ctx);
+        schemaPath = ctx.getSchemaPath().get();
 
         for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
             if (effectiveStatement instanceof DescriptionEffectiveStatementImpl) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java
index f3b9cfd196304e5a23a901d69d8d62011258fe6a..21b59e529268a29434e43a8e284c5c02b9cdda85 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java
@@ -24,7 +24,6 @@ import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
 import org.opendaylight.yangtools.yang.model.util.BaseTypes;
 import org.opendaylight.yangtools.yang.model.util.BitsType;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 
 public class BitsSpecificationEffectiveStatementImpl extends
@@ -46,7 +45,7 @@ public class BitsSpecificationEffectiveStatementImpl extends
 
         List<Bit> bitsInit = new ArrayList<>();
 
-        path = Utils.getSchemaPath(ctx.getParentContext()).createChild(QNAME);
+        path = ctx.getParentContext().getSchemaPath().get().createChild(QNAME);
 
         for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
             if (effectiveStatement instanceof Bit) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java
index d18c0b3ddef1df7f5109a24266e26b82603693b8..e8ee0aa436603ef7ecbc1852ff38884dc2e7f570 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java
@@ -29,7 +29,6 @@ import org.opendaylight.yangtools.yang.model.util.ExtendedType;
 import org.opendaylight.yangtools.yang.model.util.ExtendedType.Builder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FractionDigitsEffectiveStatementImpl;
 
@@ -85,13 +84,13 @@ public class Decimal64SpecificationEffectiveStatementImpl extends
         if (!initRanges.isEmpty() && validateRanges(initRanges)) {
             isExtended = true;
             rangeConstraints = ImmutableList.copyOf(initRanges);
-            SchemaPath parentPath = Utils.getSchemaPath(ctx.getParentContext());
+            SchemaPath parentPath = ctx.getParentContext().getSchemaPath().get();
             extendedTypeQName = QName.create(parentPath.getLastComponent().getModule(), QNAME.getLocalName());
             path = parentPath.createChild(extendedTypeQName);
         } else {
             isExtended = false;
             rangeConstraints = DEFAULT_RANGE_STATEMENTS;
-            path = Utils.getSchemaPath(ctx.getParentContext()).createChild(QNAME);
+            path = ctx.getParentContext().getSchemaPath().get().createChild(QNAME);
         }
     }
 

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java
index 87c275b0921714775d9d720914a5cd920806ef44..f4dbd351e54804a5d2c3eb711e728bcd8b5155b6 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java
@@ -17,7 +17,6 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ReferenceEffectiveStatementImpl;
@@ -34,7 +33,7 @@ public class EnumEffectiveStatementImpl extends EffectiveStatementBase<String, E
     public EnumEffectiveStatementImpl(final StmtContext<String, EnumStatement, ?> ctx) {
         super(ctx);
 
-        path = Utils.getSchemaPath(ctx);
+        path = ctx.getSchemaPath().get();
 
         for (final EffectiveStatement<?,?> effectiveStatement : effectiveSubstatements()) {
             if (effectiveStatement instanceof DescriptionEffectiveStatementImpl) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java
index 326d5a44b693a8442faf5e9d2bcc900ddb977799..74454616a9c093a388463f6c6124a5ac3d3d2add 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java
@@ -25,7 +25,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.EnumSpecific
 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
 import org.opendaylight.yangtools.yang.model.util.EnumerationType;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 
 public class EnumSpecificationEffectiveStatementImpl extends
@@ -47,7 +46,7 @@ public class EnumSpecificationEffectiveStatementImpl extends
 
         List<EnumPair> enumsInit = new ArrayList<>();
 
-        path = Utils.getSchemaPath(ctx.getParentContext()).createChild(QNAME);
+        path = ctx.getParentContext().getSchemaPath().get().createChild(QNAME);
 
         for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
             if (effectiveStatement instanceof EnumPair) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java
index 69ad633f07cf1504c7b35feed1017f668c974bac..cb8dca2e6d39557364730eddd692c726fb3a4b6c 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java
@@ -25,7 +25,6 @@ import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
 import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BaseEffectiveStatementImpl;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 
@@ -49,7 +48,7 @@ public class IdentityRefSpecificationEffectiveStatementImpl extends
             final StmtContext<String, IdentityRefSpecification, EffectiveStatement<String, IdentityRefSpecification>> ctx) {
         super(ctx);
 
-        path = Utils.getSchemaPath(ctx.getParentContext()).createChild(QNAME);
+        path = ctx.getParentContext().getSchemaPath().get().createChild(QNAME);
 
         final BaseEffectiveStatementImpl base = firstEffective(BaseEffectiveStatementImpl.class);
         if (base != null) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerEffectiveImplBase.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerEffectiveImplBase.java
index c1c6a07301f1121acb2be364b76a112ece9904dc..872315af09ed5cf3a278b202529e753bf1662a09 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerEffectiveImplBase.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerEffectiveImplBase.java
@@ -22,7 +22,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
 import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 
 abstract class IntegerEffectiveImplBase extends
@@ -42,7 +41,7 @@ abstract class IntegerEffectiveImplBase extends
         super(ctx);
 
         this.qName = QName.create(YangConstants.RFC6020_YANG_MODULE, localName);
-        path = Utils.getSchemaPath(ctx);
+        path = ctx.getSchemaPath().get();
 
         final String rangeDescription = "Integer values between " + minRange + " and " + maxRange + ", inclusively.";
         final RangeConstraint defaultRange = new RangeConstraintEffectiveImpl(minRange, maxRange,

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java
index 02f891c3cd26963734552b819425242996d1c144..8af6d8dfe7276d726711d433746e7fd18f0b2202 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java
@@ -23,7 +23,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpeci
 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
 import org.opendaylight.yangtools.yang.model.util.Leafref;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PathEffectiveStatementImpl;
 
@@ -43,7 +42,7 @@ public class LeafrefSpecificationEffectiveStatementImpl extends EffectiveStateme
     public LeafrefSpecificationEffectiveStatementImpl(final StmtContext<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> ctx) {
         super(ctx);
 
-        path = Utils.getSchemaPath(ctx.getParentContext()).createChild(QNAME);
+        path = ctx.getParentContext().getSchemaPath().get().createChild(QNAME);
 
         for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
             if (effectiveStatement instanceof PathEffectiveStatementImpl) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerEffectiveImplBase.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerEffectiveImplBase.java
index 12b9b35bdb2e5adecb78a2955ce7e06e452ec294..8cbb1d5a9190e7d2eb9ee55768ec2d5ea34d7e24 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerEffectiveImplBase.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerEffectiveImplBase.java
@@ -22,7 +22,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
 
 abstract class UnsignedIntegerEffectiveImplBase extends
@@ -43,7 +42,7 @@ abstract class UnsignedIntegerEffectiveImplBase extends
         super(ctx);
 
         this.qName = QName.create(YangConstants.RFC6020_YANG_MODULE, localName);
-        path = Utils.getSchemaPath(ctx);
+        path = ctx.getSchemaPath().get();
 
         final String rangeDescription = "Integer values between " + MIN_RANGE + " and " + maxRange + ", inclusively.";
         final RangeConstraint defaultRange = new RangeConstraintEffectiveImpl(MIN_RANGE, maxRange,