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 fd16fa23ed174832e1b0d8046d908ae628a6f0b5..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
@@ -23,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;
 
@@ -45,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();
 
@@ -59,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);
@@ -92,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);
@@ -221,10 +214,8 @@ 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> {
+    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;
@@ -236,7 +227,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             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;
@@ -264,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);
@@ -277,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);
             }
 
@@ -308,7 +297,7 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
             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;