From: Robert Varga Date: Sun, 26 Jan 2020 18:08:32 +0000 (+0100) Subject: Introduce AbstractModelStatement X-Git-Tag: v3.0.10~52 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F73%2F87273%2F1;p=yangtools.git 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 (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 5b319d39c4..39c34e14eb 100644 --- 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 implements DeclaredStatement { +public abstract class AbstractDeclaredStatement extends AbstractModelStatement implements DeclaredStatement { protected AbstractDeclaredStatement() { } @@ -37,35 +37,17 @@ public abstract class AbstractDeclaredStatement 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> 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> unmaskSubstatements( + @SuppressWarnings({ "rawtypes", "unchecked" }) + protected static final @NonNull ImmutableList> unmaskList( final @NonNull Object masked) { - return masked instanceof ImmutableList ? (ImmutableList>) 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 extends AbstractDeclaredStatement { 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 95d3931b8f..18debdbd3f 100644 --- 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> - implements EffectiveStatement { + extends AbstractModelStatement implements EffectiveStatement { @Override public final > V get(final Class namespace, final K identifier) { return getAll(namespace).get(requireNonNull(identifier)); @@ -62,4 +62,18 @@ public abstract class AbstractEffectiveStatement 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> 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 index 0000000000..908e7d97cf --- /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 implements ModelStatement { + + /** + * 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 @NonNull ImmutableList unmaskList(final @NonNull Object masked, + final @NonNull Class type) { + return masked instanceof ImmutableList ? (ImmutableList) 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 5a8d4467a1..8e0fa7a537 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularBelongsToEffectiveStatement(final BelongsToStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 2227403e94..a3828048d1 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 a6e7613d7b..58c1bd35aa 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularContactEffectiveStatement(final ContactStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 f490af4296..d91579c5c4 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 2033def96c..e272210144 100644 --- 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> effectiveSubstatements() { - if (substatements instanceof ImmutableList) { - return (ImmutableList>) 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 6f5db74199..4c41633533 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularDefaultEffectiveStatement(final DefaultStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 259a17e154..a5dadf3be7 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 519515726e..b4358c2ed4 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularDescriptionEffectiveStatement(final DescriptionStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 a504d1fa3d..a8a5c339ba 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 3cf53df126..b0ee0fcdd7 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularErrorAppTagEffectiveStatement(final ErrorAppTagStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 2cefb67f41..df2c61aa96 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 b825a0338d..8ce5722e5f 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularErrorMessageEffectiveStatement(final ErrorMessageStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 54a591d726..c7e64e0831 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 a31624443a..f7d5fa9e9d 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularForeignKeyEffectiveStatement(final KeyStatement declared, final Collection argument, final ImmutableList> substatements) { super(declared, argument); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 de5948d49c..0a11920750 100644 --- 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, ?, ?> context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 ade4a2d423..2667800dcd 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularLocalKeyEffectiveStatement(final KeyStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 d9c599fa34..26330b704d 100644 --- 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, MandatoryMixin, MustConstraintMixin { - // 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> 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> effectiveSubstatements() { - if (substatements instanceof ImmutableList) { - return (ImmutableList>) 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 bd30991073..b34f16967d 100644 --- 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, DataSchemaNodeMixin, MustConstraintMixin { - // 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> 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> effectiveSubstatements() { - if (substatements instanceof ImmutableList) { - return (ImmutableList>) 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 4263f58a27..4e2cf72dbe 100644 --- 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, NotificationNodeContainerMixin, ActionNodeContainerMixin, MustConstraintMixin { 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> effectiveSubstatements() { - return (ImmutableList) listFrom(substatements, EffectiveStatement.class); + return unmaskList(substatements); } @Override @@ -97,7 +93,7 @@ abstract class AbstractListEffectiveStatement @Override public final List 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 @NonNull ImmutableList listFrom(final Object obj, final Class type) { - if (obj instanceof ImmutableList) { - return (ImmutableList) 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 3d67c146ba..4df0313011 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularOrderedByEffectiveStatement(final OrderedByStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 6055be42f5..31d53588f7 100644 --- 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> substatements) { super(argument); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 a131aa6d2e..f46769ef27 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularPrefixEffectiveStatement(final PrefixStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 621c387c41..cff0a203a3 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 fa045b2a41..d4276392cf 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularPresenceEffectiveStatement(final PresenceStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 5e97171d68..e97fc8279f 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 3ef9ab7a9d..07f98a9ee8 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularReferenceEffectiveStatement(final ReferenceStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 abc2989ba5..e5f874df8a 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> 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 284cc597b3..04901639f2 100644 --- 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> substatements; + private final @NonNull Object substatements; RegularUnitsEffectiveStatement(final UnitsStatement declared, final ImmutableList> substatements) { super(declared); - this.substatements = requireNonNull(substatements); + this.substatements = maskList(substatements); } @Override public ImmutableList> 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 b6d278f054..a4551146cd 100644 --- 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 context, final ImmutableList> substatements) { super(context); - this.substatements = maskSubstatements(substatements); + this.substatements = maskList(substatements); } @Override public Collection> declaredSubstatements() { - return unmaskSubstatements(substatements); + return unmaskList(substatements); } }