Make BitsTypeDefinition.Bit only a DocumentedNode.WithStatus

[yangtools.git] / yang / yang-parser-rfc7950 / src / main / java / org / opendaylight / yangtools / yang / parser / rfc7950 / stmt / AbstractDeclaredEffectiveStatement.java

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 fe88538bf05baa5db1778db47e8dc8185705df4f..bc09f534e609bd9993e950ec7543233f6c196fca 100644 (file)
--- 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
@@ -13,6 +13,7 @@ import static java.util.Objects.requireNonNull;
 import com.google.common.annotations.Beta;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import org.eclipse.jdt.annotation.NonNull;
@@ -28,7 +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.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;
 
 /**
@@ -84,7 +87,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty();
         }
 
-        protected abstract ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
+        protected abstract Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
     }
 
     /**
@@ -107,7 +110,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             return super.getNamespaceContents(namespace);
         }
 
-        protected abstract ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
+        protected abstract Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
     }
 
     /**
@@ -131,6 +134,46 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         }
     }
 
+    /**
+     * Utility class for implementing DataNodeContainer-type statements.
+     */
+    public abstract static class DefaultDataNodeContainer<A, D extends DeclaredStatement<A>> extends Default<A, D>
+            implements DataNodeContainerMixin<A, D> {
+        private final @NonNull ImmutableMap<QName, DataSchemaNode> dataChildren;
+        private final @NonNull Object substatements;
+
+        protected DefaultDataNodeContainer(final D declared, final StatementSourceReference ref,
+                final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+            super(declared);
+            this.substatements = maskList(substatements);
+
+            // Note: we do not leak this map, so iteration order does not matter
+            final Map<QName, DataSchemaNode> tmp = new HashMap<>();
+
+            for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
+                if (stmt instanceof DataSchemaNode) {
+                    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);
+                }
+            }
+
+            dataChildren = ImmutableMap.copyOf(tmp);
+        }
+
+        @Override
+        public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+            return unmaskList(substatements);
+        }
+
+        @Override
+        public final Optional<DataSchemaNode> findDataChildByName(final QName name) {
+            return Optional.ofNullable(dataChildren.get(requireNonNull(name)));
+        }
+    }
+
     /**
      * An extra building block on top of {@link Default}, which is wiring {@link #argument()} to the declared statement.
      * This is mostly useful for arguments that are not subject to inference transformation -- for example Strings in
@@ -176,14 +219,30 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      */
     public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>,
             E extends SchemaTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+                E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(declared, ctx, substatements);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
         private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
         private final @NonNull D declared;
 
         protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
-            this.schemaTree = AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(
-                ctx.getStatementSourceReference(), substatements);
+            this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(
+                ctx.getStatementSourceReference(), substatements));
         }
 
         @Override
@@ -192,7 +251,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         }
 
         @Override
-        protected final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
+        protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
             return schemaTree;
         }
     }
@@ -207,6 +266,22 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      */
     public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>,
             E extends DataTreeAwareEffectiveStatement<A, D>> extends WithDataTree<A, D, E> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+                E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(declared, ctx, substatements);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
         private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
         private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
         private final @NonNull D declared;
@@ -215,8 +290,9 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
             final StatementSourceReference ref = ctx.getStatementSourceReference();
-            this.schemaTree = AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(ref, substatements);
-            this.dataTree = AbstractSchemaEffectiveDocumentedNode.createDataTreeNamespace(ref, schemaTree);
+            final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(ref, substatements);
+            this.schemaTree = ImmutableMap.copyOf(schema);
+            this.dataTree = createDataTreeNamespace(ref, schema.values(), schemaTree);
         }
 
         @Override
@@ -225,12 +301,12 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         }
 
         @Override
-        protected final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
+        protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
             return schemaTree;
         }
 
         @Override
-        protected final ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace() {
+        protected final Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace() {
             return dataTree;
         }
     }