Bug 8126 - Some augments are not being processed

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

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
index b570d68908fc8149754195e86c9e0969d905a008..4069da268a01bfec41671d3914ca1e0fa0463e24 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
@@ -18,6 +18,7 @@ import java.util.Set;
 import java.util.regex.Pattern;
 import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.YangVersion;
 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
@@ -147,7 +148,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                         augmentTargetCtx.addEffectiveSubstatement(augmentSourceCtx);
                         updateAugmentOrder(augmentSourceCtx);
                     } catch (final SourceException e) {
-                        LOG.debug("Failed to add augmentation {} defined at {}",
+                        LOG.warn("Failed to add augmentation {} defined at {}",
                             augmentTargetCtx.getStatementSourceReference(),
                                 augmentSourceCtx.getStatementSourceReference(), e);
                     }
@@ -203,6 +204,12 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.getParentContext().getPublicDefinition()
                     .getDeclaredRepresentationClass()) ? CopyType.ADDED_BY_USES_AUGMENTATION
                     : CopyType.ADDED_BY_AUGMENTATION;
+            /*
+             * Since Yang 1.1, if an augmentation is made conditional with a
+             * "when" statement, it is allowed to add mandatory nodes.
+             */
+            final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
+                    && isConditionalAugmentStmt(sourceCtx);
 
             final Collection<StatementContextBase<?, ?, ?>> declared = sourceCtx.declaredSubstatements();
             final Collection<StatementContextBase<?, ?, ?>> effective = sourceCtx.effectiveSubstatements();
@@ -210,21 +217,36 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
 
             for (final StatementContextBase<?, ?, ?> originalStmtCtx : declared) {
                 if (StmtContextUtils.areFeaturesSupported(originalStmtCtx)) {
-                    copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer);
+                    copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
                 }
             }
             for (final StatementContextBase<?, ?, ?> originalStmtCtx : effective) {
-                copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer);
+                copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
             }
 
             targetCtx.addEffectiveSubstatements(buffer);
         }
 
+        /**
+         * Checks whether supplied statement context is conditional augment
+         * statement.
+         *
+         * @param ctx
+         *            statement context to be checked
+         *
+         * @return true if supplied statement context is conditional augment
+         *         statement, otherwise false
+         */
+        private static boolean isConditionalAugmentStmt(final StatementContextBase<?, ?, ?> ctx) {
+            return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT
+                    && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
+        }
+
         private static void copyStatement(final StatementContextBase<?, ?, ?> original,
                 final StatementContextBase<?, ?, ?> target, final CopyType typeOfCopy,
-                final Collection<StatementContextBase<?, ?, ?>> buffer) {
+                final Collection<StatementContextBase<?, ?, ?>> buffer, final boolean skipCheckOfMandatoryNodes) {
             if (needToCopyByAugment(original)) {
-                validateNodeCanBeCopiedByAugment(original, target, typeOfCopy);
+                validateNodeCanBeCopiedByAugment(original, target, typeOfCopy, skipCheckOfMandatoryNodes);
 
                 final StatementContextBase<?, ?, ?> copy = original.createCopy(target, typeOfCopy);
                 buffer.add(copy);
@@ -234,13 +256,14 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
         }
 
         private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
-                final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy) {
+                final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy, final boolean skipCheckOfMandatoryNodes) {
 
             if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
                 return;
             }
 
-            if (typeOfCopy == CopyType.ADDED_BY_AUGMENTATION && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
+            if (!skipCheckOfMandatoryNodes && typeOfCopy == CopyType.ADDED_BY_AUGMENTATION
+                    && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
                 checkForMandatoryNodes(sourceCtx);
             }
 
@@ -306,11 +329,16 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                 }
 
                 /*
-                 * If target or one of its parent is a presence container from
-                 * the same module, return false and skip mandatory nodes
-                 * validation
+                 * If target or one of the target's ancestors from the same namespace
+                 * is a presence container
+                 * or is non-mandatory choice
+                 * or is non-mandatory list
+                 * return false and skip mandatory nodes validation, because these nodes
+                 * are not mandatory node containers according to RFC 6020 section 3.1.
                  */
-                if (StmtContextUtils.isPresenceContainer(targetCtx)) {
+                if (StmtContextUtils.isPresenceContainer(targetCtx)
+                        || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.CHOICE)
+                        || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.LIST)) {
                     return false;
                 }
             } while ((targetCtx = targetCtx.getParentContext()) != root);