Bug 7051 - moving of SubstatementValidator into spi.meta package

[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / rfc6020 / UsesStatementImpl.java

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
index 6682a3ab54e8c9a3da85ab95d3857d8162939fb6..7561570661490cf1b1d0830b9c9375d6fd2867a8 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
@@ -28,7 +28,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
 import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
@@ -41,6 +40,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
@@ -50,7 +50,6 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UsesEffecti
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
 public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implements UsesStatement {
     private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
             .USES)
@@ -78,13 +77,13 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
 
         @Override
         public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
-            return Utils.qNameFromArgument(ctx, value);
+            return StmtContextUtils.qnameFromArgument(ctx, value);
         }
 
         @Override
         public void onFullDefinitionDeclared(
-                final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
-            if (!StmtContextUtils.areFeaturesSupported(usesNode)) {
+                final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
+            if (!usesNode.isSupportedByFeatures()) {
                 return;
             }
             super.onFullDefinitionDeclared(usesNode);
@@ -199,21 +198,21 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
      * @throws SourceException
      *             instance of SourceException
      */
-    private static void copyFromSourceToTarget(final StmtContext<?, ?, ?> sourceGrpStmtCtx,
+    private static void copyFromSourceToTarget(final Mutable<?, ?, ?> sourceGrpStmtCtx,
             final StatementContextBase<?, ?, ?> targetCtx,
             final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
-        final Collection<StatementContextBase<?, ?, ?>> declared = sourceGrpStmtCtx.declaredSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> effective = sourceGrpStmtCtx.effectiveSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+        final Collection<? extends Mutable<?, ?, ?>> declared = sourceGrpStmtCtx.mutableDeclaredSubstatements();
+        final Collection<? extends Mutable<?, ?, ?>> effective = sourceGrpStmtCtx.mutableEffectiveSubstatements();
+        final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
         final QNameModule newQNameModule = getNewQNameModule(targetCtx, sourceGrpStmtCtx);
 
-        for (final StatementContextBase<?, ?, ?> original : declared) {
-            if (StmtContextUtils.areFeaturesSupported(original)) {
+        for (final Mutable<?, ?, ?> original : declared) {
+            if (original.isSupportedByFeatures()) {
                 copyStatement(original, targetCtx, newQNameModule, buffer);
             }
         }
 
-        for (final StatementContextBase<?, ?, ?> original : effective) {
+        for (final Mutable<?, ?, ?> original : effective) {
             copyStatement(original, targetCtx, newQNameModule, buffer);
         }
 
@@ -221,12 +220,11 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
         usesNode.addAsEffectOfStatement(buffer);
     }
 
-    private static void copyStatement(final StatementContextBase<?, ?, ?> original,
+    private static void copyStatement(final Mutable<?, ?, ?> original,
             final StatementContextBase<?, ?, ?> targetCtx, final QNameModule targetModule,
-            final Collection<StatementContextBase<?, ?, ?>> buffer) {
+            final Collection<Mutable<?, ?, ?>> buffer) {
         if (needToCopyByUses(original)) {
-            final StatementContextBase<?, ?, ?> copy = original.createCopy(targetModule, targetCtx,
-                    CopyType.ADDED_BY_USES);
+            final Mutable<?, ?, ?> copy = original.createCopy(targetModule, targetCtx, CopyType.ADDED_BY_USES);
             buffer.add(copy);
         } else if (isReusedByUsesOnTop(original)) {
             buffer.add(original);
@@ -267,7 +265,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
     public static void resolveUsesNode(
             final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode,
             final StatementContextBase<?, ?, ?> targetNodeStmtCtx) {
-        for (final StatementContextBase<?, ?, ?> subStmtCtx : usesNode.declaredSubstatements()) {
+        for (final Mutable<?, ?, ?> subStmtCtx : usesNode.mutableDeclaredSubstatements()) {
             if (StmtContextUtils.producesDeclared(subStmtCtx, RefineStatement.class)
                     && areFeaturesSupported(subStmtCtx)) {
                 performRefine(subStmtCtx, targetNodeStmtCtx);
@@ -279,48 +277,47 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
         /*
          * In case of Yang 1.1, checks whether features are supported.
          */
-        return !YangVersion.VERSION_1_1.equals(subStmtCtx.getRootVersion()) || StmtContextUtils
-                .areFeaturesSupported(subStmtCtx);
+        return !YangVersion.VERSION_1_1.equals(subStmtCtx.getRootVersion()) || subStmtCtx.isSupportedByFeatures();
     }
 
-    private static void performRefine(final StatementContextBase<?, ?, ?> refineCtx,
+    private static void performRefine(final Mutable<?, ?, ?> subStmtCtx,
             final StatementContextBase<?, ?, ?> usesParentCtx) {
 
-        final Object refineArgument = refineCtx.getStatementArgument();
+        final Object refineArgument = subStmtCtx.getStatementArgument();
         InferenceException.throwIf(!(refineArgument instanceof SchemaNodeIdentifier),
-            refineCtx.getStatementSourceReference(),
+            subStmtCtx.getStatementSourceReference(),
             "Invalid refine argument %s. It must be instance of SchemaNodeIdentifier.", refineArgument);
 
         final SchemaNodeIdentifier refineTargetNodeIdentifier = (SchemaNodeIdentifier) refineArgument;
         final StatementContextBase<?, ?, ?> refineTargetNodeCtx = Utils.findNode(usesParentCtx,
                 refineTargetNodeIdentifier);
 
-        InferenceException.throwIfNull(refineTargetNodeCtx, refineCtx.getStatementSourceReference(),
+        InferenceException.throwIfNull(refineTargetNodeCtx, subStmtCtx.getStatementSourceReference(),
             "Refine target node %s not found.", refineTargetNodeIdentifier);
 
         if (StmtContextUtils.isUnknownStatement(refineTargetNodeCtx)) {
             LOG.debug(
                     "Refine node '{}' in uses '{}' has target node unknown statement '{}'. Refine has been skipped. At line: {}",
-                    refineCtx.getStatementArgument(), refineCtx.getParentContext().getStatementArgument(),
-                    refineTargetNodeCtx.getStatementArgument(), refineCtx.getStatementSourceReference());
-            refineCtx.addAsEffectOfStatement(refineTargetNodeCtx);
+                    subStmtCtx.getStatementArgument(), subStmtCtx.getParentContext().getStatementArgument(),
+                    refineTargetNodeCtx.getStatementArgument(), subStmtCtx.getStatementSourceReference());
+            subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx);
             return;
         }
 
-        addOrReplaceNodes(refineCtx, refineTargetNodeCtx);
-        refineCtx.addAsEffectOfStatement(refineTargetNodeCtx);
+        addOrReplaceNodes(subStmtCtx, refineTargetNodeCtx);
+        subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx);
     }
 
-    private static void addOrReplaceNodes(final StatementContextBase<?, ?, ?> refineCtx,
+    private static void addOrReplaceNodes(final Mutable<?, ?, ?> subStmtCtx,
             final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
-        for (final StatementContextBase<?, ?, ?> refineSubstatementCtx : refineCtx.declaredSubstatements()) {
+        for (final Mutable<?, ?, ?> refineSubstatementCtx : subStmtCtx.mutableDeclaredSubstatements()) {
             if (isSupportedRefineSubstatement(refineSubstatementCtx)) {
                 addOrReplaceNode(refineSubstatementCtx, refineTargetNodeCtx);
             }
         }
     }
 
-    private static void addOrReplaceNode(final StatementContextBase<?, ?, ?> refineSubstatementCtx,
+    private static void addOrReplaceNode(final Mutable<?, ?, ?> refineSubstatementCtx,
             final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
 
         final StatementDefinition refineSubstatementDef = refineSubstatementCtx.getPublicDefinition();
@@ -367,11 +364,11 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
 
     private static QNameModule getNewQNameModule(final StmtContext<?, ?, ?> targetCtx,
             final StmtContext<?, ?, ?> stmtContext) {
-        if (targetCtx.isRootContext()) {
+        if (targetCtx.getParentContext() == null) {
             return targetCtx.getFromNamespace(ModuleCtxToModuleQName.class, targetCtx);
         }
         if (targetCtx.getPublicDefinition() == YangStmtMapping.AUGMENT) {
-            return Utils.getRootModuleQName(targetCtx);
+            return StmtContextUtils.getRootModuleQName(targetCtx);
         }
 
         final Object targetStmtArgument = targetCtx.getStatementArgument();