X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-rfc7950%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Frfc7950%2Fstmt%2FAbstractDeclaredEffectiveStatement.java;h=8d233f450ad77ab9fb034a0ee1f0ff218ebc8618;hb=ae91250ea3b3cf319b5600882a9a500beb02c4b3;hp=bc09f534e609bd9993e950ec7543233f6c196fca;hpb=8757b4be31e9b1b203319a84b2a8466819846063;p=yangtools.git

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java
index bc09f534e6..8d233f450a 100644
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java
@@ -29,10 +29,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStat
 import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.spi.meta.AbstractEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.spi.meta.SubstatementIndexingException;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataNodeContainerMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
 
 /**
  * Base stateless superclass for statements which (logically) always have an associated {@link DeclaredStatement}. This
@@ -78,13 +77,13 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         }
 
         /**
-         * Indexing support for {@link DataNodeContainer#findDataChildByName(QName)}.
+         * Indexing support for {@link DataNodeContainer#dataChildByName(QName)}.
          */
-        protected final Optional<DataSchemaNode> findDataSchemaNode(final QName name) {
+        protected final @Nullable DataSchemaNode dataSchemaNode(final QName name) {
             // Only DataNodeContainer subclasses should be calling this method
             verify(this instanceof DataNodeContainer);
             final SchemaTreeEffectiveStatement<?> child = schemaTreeNamespace().get(requireNonNull(name));
-            return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty();
+            return child instanceof DataSchemaNode ? (DataSchemaNode) child : null;
         }
 
         protected abstract Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
@@ -128,6 +127,10 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             this.declared = requireNonNull(declared);
         }
 
+        protected Default(final Default<A, D> original) {
+            this.declared = original.declared;
+        }
+
         @Override
         public final D getDeclared() {
             return declared;
@@ -142,7 +145,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         private final @NonNull ImmutableMap<QName, DataSchemaNode> dataChildren;
         private final @NonNull Object substatements;
 
-        protected DefaultDataNodeContainer(final D declared, final StatementSourceReference ref,
+        protected DefaultDataNodeContainer(final D declared,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             super(declared);
             this.substatements = maskList(substatements);
@@ -155,8 +158,10 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                     final DataSchemaNode node = (DataSchemaNode) stmt;
                     final QName id = node.getQName();
                     final DataSchemaNode prev = tmp.put(id, node);
-                    SourceException.throwIf(prev != null, ref,
-                            "Cannot add child with name %s, a conflicting child already exists", id);
+                    if (prev != null) {
+                        throw new SubstatementIndexingException(
+                            "Cannot add child with name " + id + ", a conflicting child already exists");
+                    }
                 }
             }
 
@@ -169,8 +174,8 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         }
 
         @Override
-        public final Optional<DataSchemaNode> findDataChildByName(final QName name) {
-            return Optional.ofNullable(dataChildren.get(requireNonNull(name)));
+        public final DataSchemaNode dataChildByName(final QName name) {
+            return dataChildren.get(requireNonNull(name));
         }
     }
 
@@ -194,6 +199,11 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                 this.substatements = maskList(substatements);
             }
 
+            protected WithSubstatements(final WithSubstatements<A, D> original) {
+                super(original);
+                this.substatements = original.substatements;
+            }
+
             @Override
             public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
                 return unmaskList(substatements);
@@ -204,12 +214,53 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             super(declared);
         }
 
+        protected DefaultArgument(final DefaultArgument<A, D> original) {
+            super(original);
+        }
+
         @Override
-        public final @Nullable A argument() {
+        public final A argument() {
             return getDeclared().argument();
         }
     }
 
+    /**
+     * A building block on top of {@link Default}, which adds an explicit argument value, which is not related to the
+     * context. This is mostly useful when the effective argument value reflects additional statements and similar.
+     *
+     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <D> Class representing declared version of this statement.
+     */
+    public abstract static class DefaultWithArgument<A, D extends DeclaredStatement<A>> extends Default<A, D> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>>
+                extends DefaultWithArgument<A, D> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final D declared, final A argument,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(declared, argument);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
+        private final A argument;
+
+        protected DefaultWithArgument(final D declared, final A argument) {
+            super(declared);
+            this.argument = argument;
+        }
+
+        @Override
+        public final A argument() {
+            return argument;
+        }
+    }
+
     /**
      * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked).
      *
@@ -223,12 +274,17 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                 E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
             private final @NonNull Object substatements;
 
-            protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
+            protected WithSubstatements(final D declared,
                     final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-                super(declared, ctx, substatements);
+                super(declared, substatements);
                 this.substatements = maskList(substatements);
             }
 
+            protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+                super(original);
+                this.substatements = original.substatements;
+            }
+
             @Override
             public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
                 return unmaskList(substatements);
@@ -238,11 +294,15 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
         private final @NonNull D declared;
 
-        protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
+        protected DefaultWithSchemaTree(final D declared,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
-            this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(
-                ctx.getStatementSourceReference(), substatements));
+            this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(substatements));
+        }
+
+        protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D, E> original) {
+            this.declared = original.declared;
+            this.schemaTree = original.schemaTree;
         }
 
         @Override
@@ -270,12 +330,17 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                 E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
             private final @NonNull Object substatements;
 
-            protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
+            protected WithSubstatements(final D declared,
                     final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-                super(declared, ctx, substatements);
+                super(declared, substatements);
                 this.substatements = maskList(substatements);
             }
 
+            protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+                super(original);
+                this.substatements = original.substatements;
+            }
+
             @Override
             public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
                 return unmaskList(substatements);
@@ -286,13 +351,18 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
         private final @NonNull D declared;
 
-        protected DefaultWithDataTree(final D declared, final StmtContext<?, ?, ?> ctx,
+        protected DefaultWithDataTree(final D declared,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
-            final StatementSourceReference ref = ctx.getStatementSourceReference();
-            final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(ref, substatements);
+            final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(substatements);
             this.schemaTree = ImmutableMap.copyOf(schema);
-            this.dataTree = createDataTreeNamespace(ref, schema.values(), schemaTree);
+            this.dataTree = createDataTreeNamespace(schema.values(), schemaTree);
+        }
+
+        protected DefaultWithDataTree(final DefaultWithDataTree<A, D, E> original) {
+            this.declared = original.declared;
+            this.schemaTree = original.schemaTree;
+            this.dataTree = original.dataTree;
         }
 
         @Override