* implementations.
*/
@Beta
-public abstract class AbstractDeclaredStatement<A> implements DeclaredStatement<A> {
+public abstract class AbstractDeclaredStatement<A> extends AbstractModelStatement<A> implements DeclaredStatement<A> {
protected AbstractDeclaredStatement() {
}
}
/**
- * 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> {
*/
@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>> Optional<? extends V> get(final Class<N> namespace,
final K identifier) {
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);
+ }
}
--- /dev/null
+/*
+ * 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));
+ }
+}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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;
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
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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;
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);
}
}
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);
}
}
*/
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);
}
}
*/
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;
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;
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?
}
@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
*/
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;
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;
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?
}
@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
*/
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;
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,
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
@Override
public final List<QName> getKeyDefinition() {
- return listFrom(keyDefinition, QName.class);
+ return unmaskList(keyDefinition, QName.class);
}
@Override
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));
- }
}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}
*/
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);
}
}
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);
}
}