Introduce AbstractModelStatement

Since we now have abstract classes for both declared and effective
worlds, it is useful tie the implementations together, so that it
both share vtable where ModelStatement methods are concerned.

Also unify substatement list handling between the two implementations,
sharing the utility methods to do so.

JIRA: YANGTOOLS-1065
Change-Id: I52849b2afa6a20478a980ba0992dbcc338941dd9
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
(cherry picked from commit 713fdd926360af53c70c871f441be23ef0927889)

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java
index 5b319d39c46e3c32d9939b2316ca7936d25606b3..39c34e14ebf0c3b4267b05f6ed73eb7b3f77e5f8 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java
@@ -21,7 +21,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  * implementations.
  */
 @Beta
-public abstract class AbstractDeclaredStatement<A> implements DeclaredStatement<A> {
+public abstract class AbstractDeclaredStatement<A> extends AbstractModelStatement<A> implements DeclaredStatement<A> {
     protected AbstractDeclaredStatement() {
     }
 
@@ -37,35 +37,17 @@ public abstract class AbstractDeclaredStatement<A> implements DeclaredStatement<
     }
 
     /**
-     * Utility method for squashing singleton lists into single objects. This is a CPU/mem trade-off, which we are
-     * usually willing to make: for the cost of an instanceof check we can save one object and re-create it when needed.
-     * The inverse operation is #unmaskSubstatements(Object)}.
+     * Utility method for recovering singleton lists squashed by {@link #maskList(ImmutableList)}.
      *
-     * @param substatements substatements to mask
-     * @return Masked substatements
-     * @throws NullPointerException if substatements is null
-     */
-    protected static final @NonNull Object maskSubstatements(
-            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
-        // Note: ImmutableList guarantees non-null content
-        return substatements.size() == 1 ? substatements.get(0) : substatements;
-    }
-
-    /**
-     * Utility method for recovering singleton lists squashed by {@link #maskSubstatements(ImmutableList)}.
-     *
-     * @param masked substatements to unmask
-     * @return List of substatements
+     * @param masked list to unmask
+     * @return Unmasked list
      * @throws NullPointerException if masked is null
-     * @throws ClassCastException if masked object was not produced by {@link #maskSubstatements(ImmutableList)}
+     * @throws ClassCastException if masked object does not match DeclaredStatement
      */
-    @SuppressWarnings("unchecked")
-    protected static final @NonNull ImmutableList<? extends DeclaredStatement<?>> unmaskSubstatements(
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    protected static final @NonNull ImmutableList<? extends DeclaredStatement<?>> unmaskList(
             final @NonNull Object masked) {
-        return masked instanceof ImmutableList ? (ImmutableList<? extends DeclaredStatement<?>>) masked
-                // Yes, this is ugly code, which could use an explicit verify, that would just change the what sort
-                // of exception we throw. ClassCastException is as good as VerifyException.
-                : ImmutableList.of((DeclaredStatement<?>) masked);
+        return (ImmutableList) unmaskList(masked, DeclaredStatement.class);
     }
 
     public abstract static class WithRawArgument<A> extends AbstractDeclaredStatement<A> {

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveStatement.java
index 95d3931b8f465fa5b02dab765eb79c2e9fd7067a..18debdbd3f6e3307633f0ca6bb7c5cb5245050e4 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveStatement.java
@@ -35,7 +35,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
  */
 @Beta
 public abstract class AbstractEffectiveStatement<A, D extends DeclaredStatement<A>>
-        implements EffectiveStatement<A, D> {
+        extends AbstractModelStatement<A> implements EffectiveStatement<A, D> {
     @Override
     public final <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
         return getAll(namespace).get(requireNonNull(identifier));
@@ -62,4 +62,18 @@ public abstract class AbstractEffectiveStatement<A, D extends DeclaredStatement<
             final @NonNull Class<N> namespace) {
         return Optional.empty();
     }
+
+    /**
+     * Utility method for recovering singleton lists squashed by {@link #maskList(ImmutableList)}.
+     *
+     * @param masked list to unmask
+     * @return Unmasked list
+     * @throws NullPointerException if masked is null
+     * @throws ClassCastException if masked object does not match EffectiveStatement
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    protected static final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> unmaskList(
+            final @NonNull Object masked) {
+        return (ImmutableList) unmaskList(masked, EffectiveStatement.class);
+    }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractModelStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractModelStatement.java
new file mode 100644 (file)
index 0000000..908e7d9
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractModelStatement.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
+
+import com.google.common.collect.ImmutableList;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.model.api.meta.ModelStatement;
+
+abstract class AbstractModelStatement<A> implements ModelStatement<A> {
+
+    /**
+     * Utility method for squashing singleton lists into single objects. This is a CPU/mem trade-off, which we are
+     * usually willing to make: for the cost of an instanceof check we can save one object and re-create it when needed.
+     * The inverse operation is #unmaskSubstatements(Object)}.
+     *
+     * @param list list to mask
+     * @return Masked list
+     * @throws NullPointerException if list is null
+     */
+    protected static final @NonNull Object maskList(final ImmutableList<?> list) {
+        // Note: ImmutableList guarantees non-null content
+        return list.size() == 1 ? list.get(0) : list;
+    }
+
+    /**
+     * Utility method for recovering singleton lists squashed by {@link #maskList(ImmutableList)}.
+     *
+     * @param masked list to unmask
+     * @return Unmasked list
+     * @throws NullPointerException if any argument is null
+     * @throws ClassCastException if masked object does not match expected class
+     */
+    @SuppressWarnings("unchecked")
+    protected static final <T> @NonNull ImmutableList<T> unmaskList(final @NonNull Object masked,
+            final @NonNull Class<T> type) {
+        return masked instanceof ImmutableList ? (ImmutableList<T>) masked
+                // Yes, this is ugly code, which could use an explicit verify, that would just change the what sort
+                // of exception we throw. ClassCastException is as good as VerifyException.
+                : ImmutableList.of(type.cast(masked));
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java
index 5a8d4467a17e14a8d3c829cedc07beeab93a6b90..8e0fa7a53767c1353ed4d8657bf1b557f3ea24e5 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
 
 final class RegularBelongsToEffectiveStatement extends AbstractBelongsToEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularBelongsToEffectiveStatement(final BelongsToStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java
index 2227403e949a873b6e2cee792ca12393fd1d98e4..a3828048d1790b91e064cb7b0cdd1eec4925dfda 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java
@@ -19,11 +19,11 @@ final class RegularBelongsToStatement extends AbstractBelongsToStatement {
     RegularBelongsToStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactEffectiveStatement.java
index a6e7613d7b06cd141438edfe930a46b26bdbbc20..58c1bd35aa25fd977eb918414d9ee089cca7e654 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
 
 final class RegularContactEffectiveStatement extends AbstractContactEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularContactEffectiveStatement(final ContactStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java
index f490af4296398ee096905ce8645590fe7f6b12a2..d91579c5c410c9349af1416b65c1189af8130641 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java
@@ -19,11 +19,11 @@ final class RegularContactStatement extends AbstractContactStatement {
     RegularContactStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerEffectiveStatementImpl.java
index 2033def96cac20708339abef5b44cfb6fcaf97ef..e272210144b6317c73c86403aab55dea24a4eb5e 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerEffectiveStatementImpl.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerEffectiveStatementImpl.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container;
 
-import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
@@ -68,20 +67,15 @@ public final class ContainerEffectiveStatementImpl
         EffectiveStmtUtils.checkUniqueTypedefs(ctx, substatements);
         EffectiveStmtUtils.checkUniqueUses(ctx, substatements);
 
-        this.substatements = substatements.size() == 1 ? substatements.get(0) : substatements;
+        this.substatements = maskList(substatements);
         this.path = requireNonNull(path);
         this.original = original;
         this.flags = flags;
     }
 
-    @SuppressWarnings("unchecked")
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        if (substatements instanceof ImmutableList) {
-            return (ImmutableList<? extends EffectiveStatement<?, ?>>) substatements;
-        }
-        verify(substatements instanceof EffectiveStatement, "Unexpected substatement %s", substatements);
-        return ImmutableList.of((EffectiveStatement<?, ?>) substatements);
+        return unmaskList(substatements);
     }
 
     @Override

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultEffectiveStatement.java
index 6f5db74199a67e9d9f2b6451ff4a39c7b2ca975c..4c41633533dc626a4be600c86b9b9b9c8cd92d75 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
 
 final class RegularDefaultEffectiveStatement extends AbstractDefaultEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularDefaultEffectiveStatement(final DefaultStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java
index 259a17e15400494dde039a547c24ca2c3f53b154..a5dadf3be7cb3eb8089ad1d86ba319a296afe0df 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java
@@ -19,11 +19,11 @@ final class RegularDefaultStatement extends AbstractDefaultStatement {
     RegularDefaultStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionEffectiveStatement.java
index 519515726e12c65ab9d449bf1a6a3ae23f55ec71..b4358c2ed478f5c15ece762bedd73c24f1fd1cba 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
 
 final class RegularDescriptionEffectiveStatement extends AbstractDescriptionEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularDescriptionEffectiveStatement(final DescriptionStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java
index a504d1fa3debd6dc2c7e7a47e9fcf72781cc62c5..a8a5c339baeb47e7d631af4ec33c44d0234bf775 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java
@@ -19,11 +19,11 @@ final class RegularDescriptionStatement extends AbstractDescriptionStatement {
     RegularDescriptionStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java
index 3cf53df126cb5f85c0fc3eaba3a3f7ecab613274..b0ee0fcdd774b6b774174328519879008f4e5ca5 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
 
 final class RegularErrorAppTagEffectiveStatement extends AbstractErrorAppTagEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularErrorAppTagEffectiveStatement(final ErrorAppTagStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java
index 2cefb67f414c275423ed914f25d822209a67c2d0..df2c61aa96b55b50a55a3b993073083db605f603 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java
@@ -19,11 +19,11 @@ final class RegularErrorAppTagStatement extends AbstractErrorAppTagStatement {
     RegularErrorAppTagStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java
index b825a0338d2a2770d5697cea342f5f6924a66971..8ce5722e5fa6badeff8756c37e7117f17f15dc99 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
 
 final class RegularErrorMessageEffectiveStatement extends AbstractErrorMessageEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularErrorMessageEffectiveStatement(final ErrorMessageStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java
index 54a591d726134cad84c0efe2f6428abbe9b8879a..c7e64e08319db5b0af378a3512bd3d2078bff057 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java
@@ -19,11 +19,11 @@ final class RegularErrorMessageStatement extends AbstractErrorMessageStatement {
     RegularErrorMessageStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularForeignKeyEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularForeignKeyEffectiveStatement.java
index a31624443ab16e2ad90a43ce9992f71e5904de37..f7d5fa9e9d64ddb963412a15f8166628d574f641 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularForeignKeyEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularForeignKeyEffectiveStatement.java
@@ -7,8 +7,6 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import java.util.Collection;
 import org.eclipse.jdt.annotation.NonNull;
@@ -17,16 +15,16 @@ import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
 
 final class RegularForeignKeyEffectiveStatement extends AbstractKeyEffectiveStatement.Foreign {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularForeignKeyEffectiveStatement(final KeyStatement declared, final Collection<SchemaNodeIdentifier> argument,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared, argument);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java
index de5948d49cb9ea754a1489c55d890208b6c949d6..0a119207504d810a2d1b6b88075309edc1684ab8 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java
@@ -20,11 +20,11 @@ final class RegularKeyStatement extends AbstractKeyStatement {
     RegularKeyStatement(final StmtContext<Collection<SchemaNodeIdentifier>, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularLocalKeyEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularLocalKeyEffectiveStatement.java
index ade4a2d423a9a2a85f7f17c7152b7a157ca351b2..2667800dcd2271c490cdbe4af25effefac5c5fd9 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularLocalKeyEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularLocalKeyEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
 
 final class RegularLocalKeyEffectiveStatement extends AbstractKeyEffectiveStatement.Local {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularLocalKeyEffectiveStatement(final KeyStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf/AbstractLeafEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf/AbstractLeafEffectiveStatement.java
index d9c599fa34c952438e87060012ecd285d3c5dfb1..26330b704dbec07da440fdaee6ca2bf6296ffe1f 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf/AbstractLeafEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf/AbstractLeafEffectiveStatement.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf;
 
-import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
@@ -37,7 +36,6 @@ abstract class AbstractLeafEffectiveStatement extends AbstractDeclaredEffectiveS
         implements LeafEffectiveStatement, LeafSchemaNode, DerivableSchemaNode,
             DataSchemaNodeMixin<QName, LeafStatement>, MandatoryMixin<QName, LeafStatement>,
             MustConstraintMixin<QName, LeafStatement> {
-    // Variable: either a single substatement or an ImmutableList
     private final @NonNull Object substatements;
     private final @NonNull SchemaPath path;
     private final @NonNull TypeDefinition<?> type;
@@ -46,7 +44,7 @@ abstract class AbstractLeafEffectiveStatement extends AbstractDeclaredEffectiveS
     AbstractLeafEffectiveStatement(final LeafStatement declared, final SchemaPath path, final int flags,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = substatements.size() == 1 ? substatements.get(0) : substatements;
+        this.substatements = maskList(substatements);
         this.path = requireNonNull(path);
         this.flags = flags;
         // TODO: lazy instantiation?
@@ -54,13 +52,8 @@ abstract class AbstractLeafEffectiveStatement extends AbstractDeclaredEffectiveS
     }
 
     @Override
-    @SuppressWarnings("unchecked")
     public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        if (substatements instanceof ImmutableList) {
-            return (ImmutableList<? extends EffectiveStatement<?, ?>>) substatements;
-        }
-        verify(substatements instanceof EffectiveStatement, "Unexpected substatement %s", substatements);
-        return ImmutableList.of((EffectiveStatement<?, ?>) substatements);
+        return unmaskList(substatements);
     }
 
     @Override

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf_list/AbstractLeafListEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf_list/AbstractLeafListEffectiveStatement.java
index bd30991073f0f7fc579ec969b9abfd41c9ec6e4b..b34f16967df4d471faba1c22c9243f261884a2c1 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf_list/AbstractLeafListEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/leaf_list/AbstractLeafListEffectiveStatement.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
 
-import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
@@ -38,7 +37,6 @@ abstract class AbstractLeafListEffectiveStatement
         implements LeafListEffectiveStatement, LeafListSchemaNode, DerivableSchemaNode,
             UserOrderedMixin<QName, LeafListStatement>, DataSchemaNodeMixin<QName, LeafListStatement>,
             MustConstraintMixin<QName, LeafListStatement> {
-    // Variable: either a single substatement or an ImmutableList
     private final @NonNull Object substatements;
     private final @NonNull SchemaPath path;
     private final @NonNull TypeDefinition<?> type;
@@ -47,7 +45,7 @@ abstract class AbstractLeafListEffectiveStatement
     AbstractLeafListEffectiveStatement(final LeafListStatement declared, final SchemaPath path, final int flags,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = substatements.size() == 1 ? substatements.get(0) : substatements;
+        this.substatements = maskList(substatements);
         this.path = requireNonNull(path);
         this.flags = flags;
         // TODO: lazy instantiation?
@@ -55,13 +53,8 @@ abstract class AbstractLeafListEffectiveStatement
     }
 
     @Override
-    @SuppressWarnings("unchecked")
     public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        if (substatements instanceof ImmutableList) {
-            return (ImmutableList<? extends EffectiveStatement<?, ?>>) substatements;
-        }
-        verify(substatements instanceof EffectiveStatement, "Unexpected substatement %s", substatements);
-        return ImmutableList.of((EffectiveStatement<?, ?>) substatements);
+        return unmaskList(substatements);
     }
 
     @Override

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/list/AbstractListEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/list/AbstractListEffectiveStatement.java
index 4263f58a27a9509324d88cd60b0ca84003c24071..4e2cf72dbee2e1edc3b71c3b29156b072d53e8ad 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/list/AbstractListEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/list/AbstractListEffectiveStatement.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
 
-import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
@@ -48,10 +47,8 @@ abstract class AbstractListEffectiveStatement
             AugmentationTargetMixin<QName, ListStatement>, NotificationNodeContainerMixin<QName, ListStatement>,
             ActionNodeContainerMixin<QName, ListStatement>, MustConstraintMixin<QName, ListStatement> {
     private final int flags;
-    // Variable: either a single substatement or an ImmutableList
     private final @NonNull Object substatements;
     private final @NonNull SchemaPath path;
-    // Variable: either a single QName or an ImmutableList
     private final @NonNull Object keyDefinition;
 
     AbstractListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
@@ -63,16 +60,15 @@ abstract class AbstractListEffectiveStatement
         EffectiveStmtUtils.checkUniqueTypedefs(ctx, substatements);
         EffectiveStmtUtils.checkUniqueUses(ctx, substatements);
 
-        this.substatements = substatements.size() == 1 ? substatements.get(0) : substatements;
+        this.substatements = maskList(substatements);
         this.path = requireNonNull(path);
-        this.keyDefinition = keyDefinition.size() == 1 ? keyDefinition.get(0) : keyDefinition;
+        this.keyDefinition = maskList(keyDefinition);
         this.flags = flags;
     }
 
-    @SuppressWarnings({ "rawtypes", "unchecked" })
     @Override
     public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return (ImmutableList) listFrom(substatements, EffectiveStatement.class);
+        return unmaskList(substatements);
     }
 
     @Override
@@ -97,7 +93,7 @@ abstract class AbstractListEffectiveStatement
 
     @Override
     public final List<QName> getKeyDefinition() {
-        return listFrom(keyDefinition, QName.class);
+        return unmaskList(keyDefinition, QName.class);
     }
 
     @Override
@@ -138,13 +134,4 @@ abstract class AbstractListEffectiveStatement
     public final String toString() {
         return "list " + getQName().getLocalName();
     }
-
-    @SuppressWarnings("unchecked")
-    private static <T> @NonNull ImmutableList<T> listFrom(final Object obj, final Class<T> type) {
-        if (obj instanceof ImmutableList) {
-            return (ImmutableList<T>) obj;
-        }
-        verify(type.isInstance(obj), "Unexpected list value %s", obj);
-        return ImmutableList.of(type.cast(obj));
-    }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java
index 3d67c146ba78175d35efd867ba80c3e59d32dbeb..4df031301182c34d749109ffe865e2ffbc5369f3 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
 
 final class RegularOrderedByEffectiveStatement extends AbstractOrderedByEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularOrderedByEffectiveStatement(final OrderedByStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java
index 6055be42f57c822a7f125937bac0a18a7e969539..31d53588f73bcbda67ffad424005611446405de1 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java
@@ -18,11 +18,11 @@ final class RegularOrderedByStatement extends AbstractOrderedByStatement {
     RegularOrderedByStatement(final String argument,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(argument);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixEffectiveStatement.java
index a131aa6d2e891f3ca3b06d592f978d62efad6dad..f46769ef2718754dad530359c3dd6f8bd5aef020 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
 
 final class RegularPrefixEffectiveStatement extends AbstractPrefixEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularPrefixEffectiveStatement(final PrefixStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java
index 621c387c41c8fb905766cb2e1bb67dac31f2b88a..cff0a203a366892421a2164104109f1a12e5cc58 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java
@@ -19,11 +19,11 @@ final class RegularPrefixStatement extends AbstractPrefixStatement {
     RegularPrefixStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceEffectiveStatement.java
index fa045b2a4122ece820c4882d51f235ecc5498cb3..d4276392cf51708d94230a1482b6b54b196a8c0e 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
 
 final class RegularPresenceEffectiveStatement extends AbstractPresenceEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularPresenceEffectiveStatement(final PresenceStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java
index 5e97171d6843be67c226c7a734780aee5d456c9b..e97fc8279f9e9b77206de5282dc70966962f3a05 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java
@@ -19,11 +19,11 @@ final class RegularPresenceStatement extends AbstractPresenceStatement {
     RegularPresenceStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java
index 3ef9ab7a9d3cf78b088dd06f743c6beb7eff61fc..07f98a9ee8098311994c92a90a6acdeb357eec00 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
 
 final class RegularReferenceEffectiveStatement extends AbstractReferenceEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularReferenceEffectiveStatement(final ReferenceStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java
index abc2989ba5faec6e723294964b670570ece62d8a..e5f874df8ae47e4ba36e7026df54254f5e8601dc 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java
@@ -19,11 +19,11 @@ final class RegularReferenceStatement extends AbstractReferenceStatement {
     RegularReferenceStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsEffectiveStatement.java
index 284cc597b323daefbe7a9b3e859ea7e390ba2c52..04901639f2f8f465f304cfc0e8dc72379eea1e63 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsEffectiveStatement.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
 
 final class RegularUnitsEffectiveStatement extends AbstractUnitsEffectiveStatement {
-    private final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements;
+    private final @NonNull Object substatements;
 
     RegularUnitsEffectiveStatement(final UnitsStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.substatements = requireNonNull(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
-        return substatements;
+        return unmaskList(substatements);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java
index b6d278f0548c6b217adb0e67d46a1492476104d2..a4551146cd7b3663c915b3a7362a25b3f74ff214 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java
@@ -19,11 +19,11 @@ final class RegularUnitsStatement extends AbstractUnitsStatement {
     RegularUnitsStatement(final StmtContext<String, ?, ?> context,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         super(context);
-        this.substatements = maskSubstatements(substatements);
+        this.substatements = maskList(substatements);
     }
 
     @Override
     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
-        return unmaskSubstatements(substatements);
+        return unmaskList(substatements);
     }
 }