X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=model%2Fyang-model-spi%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Fspi%2Fmeta%2FAbstractDeclaredEffectiveStatement.java;h=f6c1c7a5aaf42131caff53d61544f5d2ab0449fe;hb=refs%2Fchanges%2F34%2F99934%2F2;hp=4db2cf10e5c39fbd640312bc95c7f50c140ee31d;hpb=45a4c4183b924cd36adf31210eef11be756ba4ba;p=yangtools.git

diff --git a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java
index 4db2cf10e5..f6c1c7a5aa 100644
--- a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java
+++ b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java
@@ -12,22 +12,24 @@ 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.Map;
 import java.util.Optional;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.Empty;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 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.StatementOrigin;
 import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement.DataTreeNamespace;
 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.SchemaTreeAwareEffectiveStatement.SchemaTreeNamespace;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefNamespace;
 
 /**
  * Base stateless superclass for statements which (logically) always have an associated {@link DeclaredStatement}. This
@@ -38,17 +40,12 @@ import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStateme
  * {@link UnsupportedOperationException} from {@link #getDeclared()}, rendering any services relying on declared
  * statement to be not available.
  *
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
  * @param <D> Class representing declared version of this statement.
  */
 @Beta
 public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredStatement<A>>
         extends AbstractEffectiveStatement<A, D> {
-    @Override
-    public final StatementOrigin statementOrigin() {
-        return StatementOrigin.DECLARATION;
-    }
-
     @Override
     public abstract @NonNull D getDeclared();
 
@@ -56,17 +53,16 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      * Base stateless superclass form {@link SchemaTreeAwareEffectiveStatement}s. It maintains the contents of schema
      * tree namespace based of effective substatements.
      *
-     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <A> Argument type ({@link Empty} if statement does not have argument.)
      * @param <D> Class representing declared version of this statement.
-     * @param <E> Class representing effective version of this statement.
      */
-    public abstract static class WithSchemaTree<A, D extends DeclaredStatement<A>,
-            E extends SchemaTreeAwareEffectiveStatement<A, D>> extends AbstractDeclaredEffectiveStatement<A, D> {
+    public abstract static class WithSchemaTree<A, D extends DeclaredStatement<A>>
+            extends AbstractDeclaredEffectiveStatement<A, D> {
         @Override
         @SuppressWarnings("unchecked")
         protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
                 final Class<N> namespace) {
-            if (SchemaTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) {
+            if (SchemaTreeNamespace.class.equals(namespace)) {
                 return Optional.of((Map<K, V>) schemaTreeNamespace());
             }
             return super.getNamespaceContents(namespace);
@@ -86,20 +82,18 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
     }
 
     /**
-     * Base stateless superclass form {@link DataTreeAwareEffectiveStatement}s. It maintains the contents of data tree
+     * Base stateless superclass for {@link DataTreeAwareEffectiveStatement}s. It maintains the contents of data tree
      * namespace based of effective substatements.
      *
-     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <A> Argument type ({@link Empty} if statement does not have argument.)
      * @param <D> Class representing declared version of this statement.
-     * @param <E> Class representing effective version of this statement.
      */
-    public abstract static class WithDataTree<A, D extends DeclaredStatement<A>,
-            E extends DataTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
+    public abstract static class WithDataTree<A, D extends DeclaredStatement<A>> extends WithSchemaTree<A, D> {
         @Override
         @SuppressWarnings("unchecked")
         protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
                 final Class<N> namespace) {
-            if (DataTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) {
+            if (DataTreeNamespace.class.equals(namespace)) {
                 return Optional.of((Map<K, V>) dataTreeNamespace());
             }
             return super.getNamespaceContents(namespace);
@@ -112,7 +106,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      * A stateful version of {@link AbstractDeclaredEffectiveStatement}, which holds (and requires) a declared
      * statement.
      *
-     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <A> Argument type ({@link Empty} if statement does not have argument.)
      * @param <D> Class representing declared version of this statement.
      */
     public abstract static class Default<A, D extends DeclaredStatement<A>>
@@ -139,7 +133,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      * {@code description}, etc. This explicitly is not true of statements which underwent namespace binding via
      * {@code uses} or similar.
      *
-     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <A> Argument type ({@link Empty} if statement does not have argument.)
      * @param <D> Class representing declared version of this statement.
      */
     public abstract static class DefaultArgument<A, D extends DeclaredStatement<A>> extends Default<A, D> {
@@ -182,7 +176,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      * 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 <A> Argument type ({@link Empty} 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> {
@@ -218,45 +212,25 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
     /**
      * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked).
      *
-     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <A> Argument type ({@link Empty} if statement does not have argument.)
      * @param <D> Class representing declared version of this statement.
-     * @param <E> Class representing effective version of this statement.
      */
-    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 ImmutableList<? extends EffectiveStatement<?, ?>> 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);
-            }
-        }
-
-        private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+    public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>> extends WithSchemaTree<A, D> {
+        private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+        private final @NonNull Object substatements;
         private final @NonNull D declared;
 
         protected DefaultWithSchemaTree(final D declared,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
-            this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(substatements));
+            this.substatements = maskList(substatements);
+            this.schemaTree = immutableNamespaceOf(createSchemaTreeNamespace(substatements));
         }
 
-        protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D, E> original) {
+        protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D> original) {
             this.declared = original.declared;
             this.schemaTree = original.schemaTree;
+            this.substatements = original.substatements;
         }
 
         @Override
@@ -264,6 +238,11 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             return declared;
         }
 
+        @Override
+        public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+            return unmaskList(substatements);
+        }
+
         @Override
         protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
             return schemaTree;
@@ -274,49 +253,55 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      * Stateful version of {@link WithDataTree}. Schema tree and data tree namespaces are eagerly instantiated
      * (and checked).
      *
-     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <A> Argument type ({@link Empty} if statement does not have argument.)
      * @param <D> Class representing declared version of this statement.
-     * @param <E> Class representing effective version of this statement.
      */
-    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 ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+    public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>> extends WithDataTree<A, D> {
+        public abstract static class WithTypedefNamespace<A, D extends DeclaredStatement<A>>
+                extends DefaultWithDataTree<A, D> {
+            protected WithTypedefNamespace(final D declared,
+                final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
                 super(declared, substatements);
-                this.substatements = maskList(substatements);
+                // Consistency check only
+                createTypedefNamespace(substatements);
             }
 
-            protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+            protected WithTypedefNamespace(final WithTypedefNamespace<A, D> original) {
                 super(original);
-                this.substatements = original.substatements;
             }
 
             @Override
-            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-                return unmaskList(substatements);
+            @SuppressWarnings("unchecked")
+            protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
+                    final Class<N> namespace) {
+                if (TypedefNamespace.class.equals(namespace)) {
+                    return Optional.of((Map<K, V>) new LinearTypedefNamespace(effectiveSubstatements()));
+                }
+                return super.getNamespaceContents(namespace);
             }
         }
 
-        private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
-        private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
+        private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+        private final @NonNull Map<QName, DataTreeEffectiveStatement<?>> dataTree;
+        private final @NonNull Object substatements;
         private final @NonNull D declared;
 
         protected DefaultWithDataTree(final D declared,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
+            this.substatements = maskList(substatements);
+
+            // Note we call schema.values() so we do not retain them, as that is just pure memory overhead
             final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(substatements);
-            this.schemaTree = ImmutableMap.copyOf(schema);
+            this.schemaTree = immutableNamespaceOf(schema);
             this.dataTree = createDataTreeNamespace(schema.values(), schemaTree);
         }
 
-        protected DefaultWithDataTree(final DefaultWithDataTree<A, D, E> original) {
+        protected DefaultWithDataTree(final DefaultWithDataTree<A, D> original) {
             this.declared = original.declared;
             this.schemaTree = original.schemaTree;
             this.dataTree = original.dataTree;
+            this.substatements = original.substatements;
         }
 
         @Override
@@ -324,6 +309,11 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             return declared;
         }
 
+        @Override
+        public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+            return unmaskList(substatements);
+        }
+
         @Override
         protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
             return schemaTree;