Rename {Data,Schema}TreeAwareEffectiveStatement.Namespace

[yangtools.git] / model / yang-model-spi / src / main / java / org / opendaylight / yangtools / yang / model / spi / meta / AbstractDeclaredEffectiveStatement.java

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 8847b96b7c1db3795c0186fbbb6305e12e309e83..f6c1c7a5aaf42131caff53d61544f5d2ab0449fe 100644 (file)
--- 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,7 +12,6 @@ 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;
@@ -24,10 +23,11 @@ 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;
 
@@ -46,11 +46,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.TypedefNamespace;
 @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();
 
@@ -60,15 +55,14 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      *
      * @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);
@@ -93,15 +87,13 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      *
      * @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);
@@ -222,11 +214,9 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      *
      * @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> {
-        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;
 
@@ -234,10 +224,10 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.declared = requireNonNull(declared);
             this.substatements = maskList(substatements);
-            this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(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;
@@ -265,12 +255,10 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      *
      * @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 WithTypedefNamespace<A, D extends DeclaredStatement<A>,
-                E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
+    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);
@@ -278,7 +266,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
                 createTypedefNamespace(substatements);
             }
 
-            protected WithTypedefNamespace(final WithTypedefNamespace<A, D, E> original) {
+            protected WithTypedefNamespace(final WithTypedefNamespace<A, D> original) {
                 super(original);
             }
 
@@ -293,8 +281,8 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             }
         }
 
-        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;
 
@@ -305,11 +293,11 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
 
             // 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;