* of this document.
*/
@Beta
-public interface AnydataSchemaNode extends DerivableSchemaNode<AnydataSchemaNode>, MandatoryAware, MustConstraintAware,
+public interface AnydataSchemaNode extends DataSchemaNode, MandatoryAware, MustConstraintAware,
EffectiveStatementEquivalent<AnydataEffectiveStatement> {
/**
* Schema of data.
* This interface was modeled according to definition in
* <a href="https://tools.ietf.org/html/rfc6020#section-7.10">[RFC-6020] The anyxml Statement</a>
*/
-public interface AnyxmlSchemaNode extends DerivableSchemaNode<AnyxmlSchemaNode>, MandatoryAware, MustConstraintAware,
+public interface AnyxmlSchemaNode extends DataSchemaNode, MandatoryAware, MustConstraintAware,
EffectiveStatementEquivalent<AnyxmlEffectiveStatement> {
}
/**
* The CaseSchemaNode interface is used to define branches of the ChoiceSchemaNode.
*/
-public interface CaseSchemaNode extends DerivableSchemaNode<CaseSchemaNode>, DataNodeContainer, AugmentationTarget,
+public interface CaseSchemaNode extends DataSchemaNode, DataNodeContainer, AugmentationTarget,
EffectiveStatementEquivalent<CaseEffectiveStatement> {
}
* A ChoiceSchemaNode defines a set of alternatives. It consists of a number of branches defined as
* ChoiceCaseSchemaNode objects.
*/
-public interface ChoiceSchemaNode extends DerivableSchemaNode<ChoiceSchemaNode>, AugmentationTarget, MandatoryAware,
+public interface ChoiceSchemaNode extends DataSchemaNode, AugmentationTarget, MandatoryAware,
EffectiveStatementEquivalent<ChoiceEffectiveStatement> {
/**
* Returns cases of choice, keyed by their {@link SchemaNode#getQName()}. Returned map does not contain null keys
* containers, those that exist only for organizing the hierarchy of data nodes, and those whose presence in the
* configuration has an explicit meaning.
*/
-public interface ContainerSchemaNode extends ContainerLike, DerivableSchemaNode<ContainerSchemaNode>,
- EffectiveStatementEquivalent<ContainerEffectiveStatement> {
+public interface ContainerSchemaNode extends ContainerLike, EffectiveStatementEquivalent<ContainerEffectiveStatement> {
/**
* Returns true if this container is marked as presence.
*
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. 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.model.api;
-
-import java.util.Optional;
-
-/**
- * Schema Node which may be derived from other schema node using augmentation or uses statement.
- *
- * @deprecated This interface's sole purpose is to aid MD-SAL binding generator, which is now in a position to provide
- * to implement its logic without this interface.
- */
-@Deprecated(since = "7.0.9", forRemoval = true)
-public interface DerivableSchemaNode<T extends DerivableSchemaNode<T>> extends DataSchemaNode {
- /**
- * If this node is added by uses, returns original node definition from grouping where it was defined.
- *
- * @return original node definition from grouping if this node is added by uses, absent otherwise
- */
- Optional<T> getOriginal();
-}
* Interface describing YANG 'leaf-list' statement.
*/
public interface LeafListSchemaNode extends TypedDataSchemaNode, MustConstraintAware, ElementCountConstraintAware,
- DerivableSchemaNode<LeafListSchemaNode>, EffectiveStatementEquivalent<LeafListEffectiveStatement> {
+ EffectiveStatementEquivalent<LeafListEffectiveStatement> {
/**
* YANG 'ordered-by' statement. It defines whether the order of entries
* within this leaf-list are determined by the user or the system. If not
* substatements is captured in the type returned via {@link #getType()}.
*/
public interface LeafSchemaNode extends TypedDataSchemaNode, MandatoryAware, MustConstraintAware,
- DerivableSchemaNode<LeafSchemaNode>, EffectiveStatementEquivalent<LeafEffectiveStatement> {
+ EffectiveStatementEquivalent<LeafEffectiveStatement> {
}
* The 'list' statement is used to define an interior data node in the schema tree. A list entry is uniquely identified
* by the values of the list's keys, if defined.
*/
-public interface ListSchemaNode extends DataNodeContainer, AugmentationTarget, DerivableSchemaNode<ListSchemaNode>,
- NotificationNodeContainer, ActionNodeContainer, ElementCountConstraintAware, MustConstraintAware,
+public interface ListSchemaNode extends DataNodeContainer, AugmentationTarget, DataSchemaNode, ActionNodeContainer,
+ NotificationNodeContainer, ElementCountConstraintAware, MustConstraintAware,
EffectiveStatementEquivalent<ListEffectiveStatement> {
/**
* Returns the list of leaf identifiers.
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
}
public static AnydataEffectiveStatement copyAnydata(final AnydataEffectiveStatement original, final QName argument,
- final int flags, final @Nullable AnydataSchemaNode newOriginal) {
+ final int flags) {
if (original instanceof RegularAnydataEffectiveStatement) {
- return new RegularAnydataEffectiveStatement((RegularAnydataEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new RegularAnydataEffectiveStatement((RegularAnydataEffectiveStatement) original, argument, flags);
} else if (original instanceof EmptyAnydataEffectiveStatement) {
- return new EmptyAnydataEffectiveStatement((EmptyAnydataEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new EmptyAnydataEffectiveStatement((EmptyAnydataEffectiveStatement) original, argument, flags);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
}
public static AnydataEffectiveStatement createAnydata(final AnydataStatement declared, final QName argument,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable AnydataSchemaNode original) {
- return substatements.isEmpty() ? new EmptyAnydataEffectiveStatement(declared, argument, flags, original)
- : new RegularAnydataEffectiveStatement(declared, argument, flags, original, substatements);
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyAnydataEffectiveStatement(declared, argument, flags)
+ : new RegularAnydataEffectiveStatement(declared, argument, flags, substatements);
}
public static AnyxmlEffectiveStatement copyAnyxml(final AnyxmlEffectiveStatement original, final QName argument,
- final int flags, final @Nullable AnyxmlSchemaNode newOriginal) {
+ final int flags) {
if (original instanceof RegularAnyxmlEffectiveStatement) {
- return new RegularAnyxmlEffectiveStatement((RegularAnyxmlEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new RegularAnyxmlEffectiveStatement((RegularAnyxmlEffectiveStatement) original, argument, flags);
} else if (original instanceof EmptyAnyxmlEffectiveStatement) {
- return new EmptyAnyxmlEffectiveStatement((EmptyAnyxmlEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new EmptyAnyxmlEffectiveStatement((EmptyAnyxmlEffectiveStatement) original, argument, flags);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
}
public static AnyxmlEffectiveStatement createAnyxml(final AnyxmlStatement declared, final QName argument,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable AnyxmlSchemaNode original) {
- return substatements.isEmpty() ? new EmptyAnyxmlEffectiveStatement(declared, argument, flags, original)
- : new RegularAnyxmlEffectiveStatement(declared, argument, flags, original, substatements);
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyAnyxmlEffectiveStatement(declared, argument, flags)
+ : new RegularAnyxmlEffectiveStatement(declared, argument, flags, substatements);
}
public static ArgumentEffectiveStatement createArgument(final ArgumentStatement declared,
}
public static CaseEffectiveStatement copyCase(final CaseEffectiveStatement original, final QName argument,
- final int flags, final @Nullable CaseSchemaNode newOriginal) {
+ final int flags) {
if (original instanceof DeclaredCaseEffectiveStatement) {
- return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, argument, flags);
} else if (original instanceof UndeclaredCaseEffectiveStatement) {
- return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, argument, flags);
} else {
throw new IllegalArgumentException("Unsupported origin " + original);
}
}
public static CaseEffectiveStatement createCase(final QName argument, final int flags,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable CaseSchemaNode original) {
- return new UndeclaredCaseEffectiveStatement(substatements, argument, flags, original);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new UndeclaredCaseEffectiveStatement(substatements, argument, flags);
}
public static CaseEffectiveStatement createCase(final CaseStatement declared, final QName argument,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable CaseSchemaNode original) {
- return new DeclaredCaseEffectiveStatement(declared, substatements, argument, flags, original);
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new DeclaredCaseEffectiveStatement(declared, substatements, argument, flags);
}
public static ChoiceEffectiveStatement copyChoice(final ChoiceEffectiveStatement original,
- final QName argument, final int flags, final @Nullable ChoiceSchemaNode newOriginal) {
+ final QName argument, final int flags) {
checkArgument(original instanceof ChoiceEffectiveStatementImpl, "Unsupported original %s", original);
- return new ChoiceEffectiveStatementImpl((ChoiceEffectiveStatementImpl) original, argument, flags, newOriginal);
+ return new ChoiceEffectiveStatementImpl((ChoiceEffectiveStatementImpl) original, argument, flags);
}
public static ChoiceEffectiveStatement createChoice(final ChoiceStatement declared, final QName argument,
final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable CaseSchemaNode defaultCase, final @Nullable ChoiceSchemaNode original) {
- return new ChoiceEffectiveStatementImpl(declared, substatements, argument, flags, defaultCase, original);
+ final @Nullable CaseSchemaNode defaultCase) {
+ return new ChoiceEffectiveStatementImpl(declared, substatements, argument, flags, defaultCase);
}
public static ConfigEffectiveStatement createConfig(final boolean argument) {
}
public static ContainerEffectiveStatement copyContainer(final ContainerEffectiveStatement original,
- final QName argument, final int flags, final @Nullable ContainerSchemaNode orig) {
+ final QName argument, final int flags) {
checkArgument(original instanceof ContainerEffectiveStatementImpl, "Unsupported original %s", original);
- return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original, argument, flags, orig);
+ return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original, argument, flags);
}
public static ContainerEffectiveStatement createContainer(final ContainerStatement declared, final QName argument,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable ContainerSchemaNode original) {
- return new ContainerEffectiveStatementImpl(declared, substatements, argument, flags, original);
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new ContainerEffectiveStatementImpl(declared, substatements, argument, flags);
}
public static DefaultEffectiveStatement createDefault(final DefaultStatement declared,
}
public static LeafEffectiveStatement copyLeaf(final LeafEffectiveStatement original, final QName argument,
- final int flags, final @Nullable LeafSchemaNode newOriginal) {
+ final int flags) {
checkArgument(original instanceof AbstractLeafEffectiveStatement, "Unsupported original %s", original);
- return new RegularLeafEffectiveStatement((AbstractLeafEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new RegularLeafEffectiveStatement((AbstractLeafEffectiveStatement) original, argument, flags);
}
public static LeafEffectiveStatement createLeaf(final LeafStatement declared, final QName argument, final int flags,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable LeafSchemaNode original) throws SubstatementIndexingException {
- return original == null ? new EmptyLeafEffectiveStatement(declared, argument, flags, substatements)
- : new RegularLeafEffectiveStatement(declared, argument, flags, substatements, original);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
+ throws SubstatementIndexingException {
+ // FIXME: YANGTOOLS-1316: instantiate RegularLeafEffectiveStatement() in argument mismatch
+ return new EmptyLeafEffectiveStatement(declared, argument, flags, substatements);
}
public static LeafListEffectiveStatement copyLeafList(final LeafListEffectiveStatement original,
- final QName argument, final int flags, final @Nullable LeafListSchemaNode newOriginal) {
+ final QName argument, final int flags) {
if (original instanceof RegularLeafListEffectiveStatement) {
- return new RegularLeafListEffectiveStatement((RegularLeafListEffectiveStatement) original, newOriginal,
- argument, flags);
+ return new RegularLeafListEffectiveStatement((RegularLeafListEffectiveStatement) original, argument, flags);
} else if (original instanceof SlimLeafListEffectiveStatement) {
- return new SlimLeafListEffectiveStatement((SlimLeafListEffectiveStatement) original, newOriginal, argument,
- flags);
+ return new SlimLeafListEffectiveStatement((SlimLeafListEffectiveStatement) original, argument, flags);
} else if (original instanceof EmptyLeafListEffectiveStatement) {
// Promote to slim
- return new SlimLeafListEffectiveStatement((EmptyLeafListEffectiveStatement) original, newOriginal, argument,
- flags);
+ return new SlimLeafListEffectiveStatement((EmptyLeafListEffectiveStatement) original, argument, flags);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
public static LeafListEffectiveStatement createLeafList(final LeafListStatement declared, final QName argument,
final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final ImmutableSet<String> defaultValues, final @Nullable ElementCountConstraint elementCountConstraint,
- final @Nullable LeafListSchemaNode original)
+ final ImmutableSet<String> defaultValues, final @Nullable ElementCountConstraint elementCountConstraint)
throws SubstatementIndexingException {
if (defaultValues.isEmpty()) {
- return original == null && elementCountConstraint == null
+ return elementCountConstraint == null
? new EmptyLeafListEffectiveStatement(declared, argument, flags, substatements)
- : new SlimLeafListEffectiveStatement(declared, argument, flags, substatements, original,
+ : new SlimLeafListEffectiveStatement(declared, argument, flags, substatements,
elementCountConstraint);
}
- return new RegularLeafListEffectiveStatement(declared, argument, flags, substatements, original, defaultValues,
+ return new RegularLeafListEffectiveStatement(declared, argument, flags, substatements, defaultValues,
elementCountConstraint);
}
}
public static ListEffectiveStatement copyList(final ListEffectiveStatement original, final QName argument,
- final int flags, final @Nullable ListSchemaNode newOriginal) {
+ final int flags) {
if (original instanceof RegularListEffectiveStatement) {
- return new RegularListEffectiveStatement((RegularListEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new RegularListEffectiveStatement((RegularListEffectiveStatement) original, argument, flags);
} else if (original instanceof EmptyListEffectiveStatement) {
- return new RegularListEffectiveStatement((EmptyListEffectiveStatement) original, argument, flags,
- newOriginal);
+ return new RegularListEffectiveStatement((EmptyListEffectiveStatement) original, argument, flags);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
public static ListEffectiveStatement createList(final ListStatement declared, final QName argument,
final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final ImmutableList<QName> keyDefinition, final @Nullable ElementCountConstraint elementCountConstraint,
- final @Nullable ListSchemaNode original) {
- return original == null && elementCountConstraint == null
+ final ImmutableList<QName> keyDefinition, final @Nullable ElementCountConstraint elementCountConstraint) {
+ return elementCountConstraint == null
? new EmptyListEffectiveStatement(declared, argument, flags, substatements, keyDefinition)
: new RegularListEffectiveStatement(declared, argument, flags, substatements, keyDefinition,
- elementCountConstraint, original);
+ elementCountConstraint);
}
public static MandatoryEffectiveStatement createMandatory(final MandatoryStatement declared) {
implements LeafEffectiveStatement, LeafSchemaNode, DataSchemaNodeMixin<LeafStatement>,
MandatoryMixin<QName, LeafStatement>, MustConstraintMixin<QName, LeafStatement> {
private final @NonNull Object substatements;
+ // FIXME: YANGTOOLS-1316: this seems to imply that argument.equals(declared.argument()) and we could save a field,
+ // except we need it in the constructors to materialize type. But if we turn it into a lazy
+ // field, we should be okay.
private final @NonNull QName argument;
private final @NonNull TypeDefinition<?> type;
+
private final int flags;
AbstractLeafEffectiveStatement(final LeafStatement declared, final QName argument, final int flags,
this.argument = requireNonNull(argument);
this.substatements = maskList(substatements);
this.flags = flags;
- // TODO: lazy instantiation?
- this.type = buildType();
+ type = buildType();
}
AbstractLeafEffectiveStatement(final AbstractLeafEffectiveStatement original, final QName argument,
final int flags) {
super(original);
this.argument = requireNonNull(argument);
- this.substatements = original.substatements;
+ substatements = original.substatements;
this.flags = flags;
- // FIXME: share with original?
- this.type = buildType();
+ type = buildType();
}
@Override
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
abstract class AbstractNonEmptyLeafListEffectiveStatement extends AbstractLeafListEffectiveStatement {
- private final @Nullable LeafListSchemaNode original;
private final @Nullable ElementCountConstraint elementCountConstraint;
AbstractNonEmptyLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final LeafListSchemaNode original, final ElementCountConstraint elementCountConstraint) {
+ final ElementCountConstraint elementCountConstraint) {
super(declared, argument, flags, substatements);
- this.original = original;
this.elementCountConstraint = elementCountConstraint;
}
AbstractNonEmptyLeafListEffectiveStatement(final AbstractNonEmptyLeafListEffectiveStatement originalEffecive,
- final LeafListSchemaNode original, final QName argument, final int flags) {
+ final QName argument, final int flags) {
super(originalEffecive, argument, flags);
elementCountConstraint = originalEffecive.elementCountConstraint;
- this.original = original;
}
AbstractNonEmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final QName argument, final int flags) {
+ final QName argument, final int flags) {
super(originalEffective, argument, flags);
elementCountConstraint = null;
- this.original = original;
- }
-
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public final Optional<LeafListSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
}
@Override
implements ChoiceEffectiveStatement, ChoiceSchemaNode, DataSchemaNodeMixin<ChoiceStatement>,
AugmentationTargetMixin<QName, ChoiceStatement>, MandatoryMixin<QName, ChoiceStatement> {
private final CaseSchemaNode defaultCase;
- private final ChoiceSchemaNode original;
private final @NonNull QName argument;
private final int flags;
public ChoiceEffectiveStatementImpl(final ChoiceStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
- final int flags, final @Nullable CaseSchemaNode defaultCase, final @Nullable ChoiceSchemaNode original) {
+ final int flags, final @Nullable CaseSchemaNode defaultCase) {
super(declared, substatements);
this.argument = requireNonNull(argument);
this.flags = flags;
this.defaultCase = defaultCase;
- this.original = original;
}
public ChoiceEffectiveStatementImpl(final ChoiceEffectiveStatementImpl origEffective, final QName argument,
- final int flags, final ChoiceSchemaNode newOriginal) {
+ final int flags) {
super(origEffective);
this.argument = requireNonNull(argument);
this.flags = flags;
defaultCase = origEffective.defaultCase;
- original = newOriginal;
}
@Override
return flags;
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<ChoiceSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
- }
-
@Override
public Optional<? extends CaseSchemaNode> findCase(final QName qname) {
final SchemaTreeEffectiveStatement<?> child = schemaTreeNamespace().get(requireNonNull(qname));
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
private final int flags;
private final @NonNull QName argument;
- private final @Nullable ContainerSchemaNode original;
public ContainerEffectiveStatementImpl(final ContainerStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
- final int flags, final @Nullable ContainerSchemaNode original) {
+ final int flags) {
super(declared, substatements);
this.argument = requireNonNull(argument);
- this.original = original;
this.flags = flags;
}
public ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective, final QName argument,
- final int flags, final @Nullable ContainerSchemaNode original) {
+ final int flags) {
super(origEffective);
this.argument = requireNonNull(argument);
- this.original = original;
this.flags = flags;
}
return argument;
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<ContainerSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
- }
-
@Override
public boolean isPresenceContainer() {
return presence();
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
public final class DeclaredCaseEffectiveStatement
extends DefaultWithDataTree<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
- private final CaseSchemaNode original;
private final @NonNull QName argument;
private final int flags;
public DeclaredCaseEffectiveStatement(final CaseStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
- final int flags, final @Nullable CaseSchemaNode original) {
+ final int flags) {
super(declared, substatements);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = original;
}
public DeclaredCaseEffectiveStatement(final DeclaredCaseEffectiveStatement origEffective, final QName argument,
- final int flags, final @Nullable CaseSchemaNode original) {
+ final int flags) {
super(origEffective);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = original;
}
@Override
return flags;
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<CaseSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
- }
-
@Override
public DataSchemaNode dataChildByName(final QName name) {
return dataSchemaNode(name);
import com.google.common.base.MoreObjects;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.OpaqueDataSchemaNodeMixin;
public class EmptyAnydataEffectiveStatement extends Default<QName, AnydataStatement>
- implements AnydataEffectiveStatement, AnydataSchemaNode,
- OpaqueDataSchemaNodeMixin<AnydataStatement, AnydataSchemaNode> {
+ implements AnydataEffectiveStatement, AnydataSchemaNode, OpaqueDataSchemaNodeMixin<AnydataStatement> {
private final @NonNull QName argument;
- private final AnydataSchemaNode original;
private final int flags;
- public EmptyAnydataEffectiveStatement(final AnydataStatement declared, final QName argument, final int flags,
- final @Nullable AnydataSchemaNode original) {
+ public EmptyAnydataEffectiveStatement(final AnydataStatement declared, final QName argument, final int flags) {
super(declared);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = original;
}
public EmptyAnydataEffectiveStatement(final EmptyAnydataEffectiveStatement original, final QName argument,
- final int flags, final @Nullable AnydataSchemaNode newOriginal) {
+ final int flags) {
super(original);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = newOriginal;
}
@Override
return flags;
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public final Optional<AnydataSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
- }
-
@Override
public final Optional<ContainerSchemaNode> getDataSchema() {
/*
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.OpaqueDataSchemaNodeMixin;
public class EmptyAnyxmlEffectiveStatement extends Default<QName, AnyxmlStatement>
- implements AnyxmlEffectiveStatement, AnyxmlSchemaNode,
- OpaqueDataSchemaNodeMixin<AnyxmlStatement, AnyxmlSchemaNode> {
+ implements AnyxmlEffectiveStatement, AnyxmlSchemaNode, OpaqueDataSchemaNodeMixin<AnyxmlStatement> {
private final @NonNull QName argument;
- private final AnyxmlSchemaNode original;
private final int flags;
- public EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final QName argument, final int flags,
- final @Nullable AnyxmlSchemaNode original) {
+ public EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final QName argument, final int flags) {
super(declared);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = original;
}
public EmptyAnyxmlEffectiveStatement(final EmptyAnyxmlEffectiveStatement original, final QName argument,
- final int flags, final @Nullable AnyxmlSchemaNode newOriginal) {
+ final int flags) {
super(original);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = newOriginal;
}
@Override
return flags;
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public final Optional<AnyxmlSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
- }
-
@Override
public final AnyxmlEffectiveStatement asEffectiveStatement() {
return this;
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
import com.google.common.collect.ImmutableList;
-import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
public final class EmptyLeafEffectiveStatement extends AbstractLeafEffectiveStatement {
public EmptyLeafEffectiveStatement(final LeafStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- // FIXME: this seems to imply that argument.equals(declared.argument()) and we could save a field
super(declared, argument, flags, substatements);
}
-
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<LeafSchemaNode> getOriginal() {
- return Optional.empty();
- }
}
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
super(original, argument, flags);
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<LeafListSchemaNode> getOriginal() {
- return Optional.empty();
- }
-
@Override
public Collection<Object> getDefaults() {
return ImmutableSet.of();
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
super(original, argument, flags);
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<ListSchemaNode> getOriginal() {
- return Optional.empty();
- }
-
@Override
public Optional<ElementCountConstraint> getElementCountConstraint() {
return Optional.empty();
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
private final @NonNull Object substatements;
public RegularAnydataEffectiveStatement(final AnydataStatement declared, final QName argument, final int flags,
- final @Nullable AnydataSchemaNode original,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, argument, flags, original);
+ super(declared, argument, flags);
this.substatements = maskList(substatements);
}
public RegularAnydataEffectiveStatement(final RegularAnydataEffectiveStatement original, final QName argument,
- final int flags, final @Nullable AnydataSchemaNode newOriginal) {
- super(original, argument, flags, newOriginal);
- this.substatements = original.substatements;
+ final int flags) {
+ super(original, argument, flags);
+ substatements = original.substatements;
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
private final @NonNull Object substatements;
public RegularAnyxmlEffectiveStatement(final AnyxmlStatement declared, final QName argument, final int flags,
- final @Nullable AnyxmlSchemaNode original,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, argument, flags, original);
+ super(declared, argument, flags);
this.substatements = maskList(substatements);
}
public RegularAnyxmlEffectiveStatement(final RegularAnyxmlEffectiveStatement original, final QName argument,
- final int flags, final @Nullable AnyxmlSchemaNode newOriginal) {
- super(original, argument, flags, newOriginal);
- this.substatements = original.substatements;
+ final int flags) {
+ super(original, argument, flags);
+ substatements = original.substatements;
}
@Override
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
import com.google.common.collect.ImmutableList;
-import java.util.Optional;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
public final class RegularLeafEffectiveStatement extends AbstractLeafEffectiveStatement {
- private final @Nullable LeafSchemaNode original;
-
public RegularLeafEffectiveStatement(final LeafStatement declared, final QName argument, final int flags,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final LeafSchemaNode original) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, argument, flags, substatements);
- this.original = original;
}
public RegularLeafEffectiveStatement(final AbstractLeafEffectiveStatement originalEffective, final QName argument,
- final int flags, final LeafSchemaNode original) {
+ final int flags) {
super(originalEffective, argument, flags);
- this.original = original;
- }
-
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<LeafSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
private final @NonNull ImmutableSet<String> defaults;
public RegularLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final LeafListSchemaNode original,
- final ImmutableSet<String> defaults, final ElementCountConstraint elementCountConstraint) {
- super(declared, argument, flags, substatements, original, elementCountConstraint);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final ImmutableSet<String> defaults,
+ final ElementCountConstraint elementCountConstraint) {
+ super(declared, argument, flags, substatements, elementCountConstraint);
this.defaults = requireNonNull(defaults);
}
public RegularLeafListEffectiveStatement(final RegularLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final QName argument, final int flags) {
- super(originalEffective, original, argument, flags);
- this.defaults = originalEffective.defaults;
+ final QName argument, final int flags) {
+ super(originalEffective, argument, flags);
+ defaults = originalEffective.defaults;
}
@Override
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
public final class RegularListEffectiveStatement extends AbstractListEffectiveStatement {
private final ElementCountConstraint elementCountConstraint;
- private final ListSchemaNode original;
public RegularListEffectiveStatement(final ListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final ImmutableList<QName> keyDefinition, final ElementCountConstraint elementCountConstraint,
- final ListSchemaNode original) {
+ final ImmutableList<QName> keyDefinition, final ElementCountConstraint elementCountConstraint) {
super(declared, argument, flags, substatements, keyDefinition);
this.elementCountConstraint = elementCountConstraint;
- this.original = original;
}
public RegularListEffectiveStatement(final RegularListEffectiveStatement originalEffective, final QName argument,
- final int flags, final ListSchemaNode original) {
+ final int flags) {
super(originalEffective, argument, flags);
elementCountConstraint = originalEffective.elementCountConstraint;
- this.original = original;
}
- public RegularListEffectiveStatement(final EmptyListEffectiveStatement originalEffective,
- final QName argument, final int flags, final ListSchemaNode original) {
+ public RegularListEffectiveStatement(final EmptyListEffectiveStatement originalEffective, final QName argument,
+ final int flags) {
super(originalEffective, argument, flags);
elementCountConstraint = null;
- this.original = original;
- }
-
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<ListSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
}
@Override
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
public final class SlimLeafListEffectiveStatement extends AbstractNonEmptyLeafListEffectiveStatement {
public SlimLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final LeafListSchemaNode original, final ElementCountConstraint elementCountConstraint) {
- super(declared, argument, flags, substatements, original, elementCountConstraint);
+ final ElementCountConstraint elementCountConstraint) {
+ super(declared, argument, flags, substatements, elementCountConstraint);
}
- public SlimLeafListEffectiveStatement(final SlimLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final QName argument, final int flags) {
- super(originalEffective, original, argument, flags);
+ public SlimLeafListEffectiveStatement(final SlimLeafListEffectiveStatement originalEffective, final QName argument,
+ final int flags) {
+ super(originalEffective, argument, flags);
}
- public SlimLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final QName argument, final int flags) {
- super(originalEffective, original, argument, flags);
+ public SlimLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective, final QName argument,
+ final int flags) {
+ super(originalEffective, argument, flags);
}
@Override
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
public final class UndeclaredCaseEffectiveStatement
extends DefaultWithDataTree<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
- private final @Nullable CaseSchemaNode original;
private final @NonNull QName argument;
private final int flags;
public UndeclaredCaseEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final QName argument, final int flags, final @Nullable CaseSchemaNode original) {
+ final QName argument, final int flags) {
super(substatements);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = original;
}
public UndeclaredCaseEffectiveStatement(final UndeclaredCaseEffectiveStatement origEffective, final QName argument,
- final int flags, final @Nullable CaseSchemaNode original) {
+ final int flags) {
super(origEffective);
this.argument = requireNonNull(argument);
this.flags = flags;
- this.original = original;
}
@Override
return flags;
}
- @Override
- @Deprecated(since = "7.0.9", forRemoval = true)
- public Optional<CaseSchemaNode> getOriginal() {
- return Optional.ofNullable(original);
- }
-
@Override
public DataSchemaNode dataChildByName(final QName name) {
return dataSchemaNode(name);
import org.opendaylight.yangtools.yang.model.api.CopyableNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
*
* @param <D> Class representing declared version of this statement.
*/
- public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>, S extends DerivableSchemaNode<S>>
- extends DerivableSchemaNode<S>, DataSchemaNodeMixin<D>, DocumentedNodeMixin.WithStatus<QName, D>,
- MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
+ public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
+ extends DataSchemaNodeMixin<D>, DocumentedNodeMixin.WithStatus<QName, D>, MandatoryMixin<QName, D>,
+ MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
@Override
default QName getQName() {
return argument();
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.List;
import java.util.Objects;
import java.util.regex.Pattern;
}
@Override
+ @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST", justification = "Cast of original(), should be always safe")
protected final AugmentEffectiveStatement createEffective(
final Current<SchemaNodeIdentifier, AugmentStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
return EffectiveStatements.createAugment(stmt.declared(), stmt.getArgument(), flags,
- stmt.moduleName().getModule(), substatements, stmt.original(AugmentationSchemaNode.class));
+ stmt.moduleName().getModule(), substatements, (AugmentationSchemaNode) stmt.original());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
public ListEffectiveStatement copyEffective(final Current<QName, ListStatement> stmt,
final ListEffectiveStatement original) {
return EffectiveStatements.copyList(original, stmt.getArgument(),
- computeFlags(stmt, original.effectiveSubstatements()), stmt.original(ListSchemaNode.class));
+ computeFlags(stmt, original.effectiveSubstatements()));
}
@Override
try {
return EffectiveStatements.createList(stmt.declared(), stmt.getArgument(), flags, substatements,
- keyDefinition, EffectiveStmtUtils.createElementCountConstraint(substatements).orElse(null),
- stmt.original(ListSchemaNode.class));
+ keyDefinition, EffectiveStmtUtils.createElementCountConstraint(substatements).orElse(null));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
@Override
protected AnydataEffectiveStatement createEffective(final Current<QName, AnydataStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return EffectiveStatements.createAnydata(stmt.declared(), stmt.getArgument(),
- createFlags(stmt, substatements), substatements, stmt.original(AnydataSchemaNode.class));
+ return EffectiveStatements.createAnydata(stmt.declared(), stmt.getArgument(), createFlags(stmt, substatements),
+ substatements);
}
@Override
public AnydataEffectiveStatement copyEffective(final Current<QName, AnydataStatement> stmt,
final AnydataEffectiveStatement original) {
return EffectiveStatements.copyAnydata(original, stmt.getArgument(),
- createFlags(stmt, original.effectiveSubstatements()), stmt.original(AnydataSchemaNode.class));
+ createFlags(stmt, original.effectiveSubstatements()));
}
@Override
protected AnyxmlEffectiveStatement createEffective(final Current<QName, AnyxmlStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return EffectiveStatements.createAnyxml(stmt.declared(), stmt.getArgument(), createFlags(stmt, substatements),
- substatements, stmt.original(AnyxmlSchemaNode.class));
+ substatements);
}
@Override
public AnyxmlEffectiveStatement copyEffective(final Current<QName, AnyxmlStatement> stmt,
final AnyxmlEffectiveStatement original) {
return EffectiveStatements.copyAnyxml(original, stmt.getArgument(),
- createFlags(stmt, original.effectiveSubstatements()), stmt.original(AnyxmlSchemaNode.class));
+ createFlags(stmt, original.effectiveSubstatements()));
}
@Override
protected CaseEffectiveStatement copyDeclaredEffective(final Current<QName, CaseStatement> stmt,
final CaseEffectiveStatement original) {
return EffectiveStatements.copyCase(original, stmt.getArgument(),
- computeFlags(stmt, original.effectiveSubstatements()), stmt.original(CaseSchemaNode.class));
+ computeFlags(stmt, original.effectiveSubstatements()));
}
@Override
protected CaseEffectiveStatement copyUndeclaredEffective(final Current<QName, CaseStatement> stmt,
final CaseEffectiveStatement original) {
return EffectiveStatements.copyCase(original, stmt.getArgument(),
- computeFlags(stmt, original.effectiveSubstatements()), stmt.original(CaseSchemaNode.class));
+ computeFlags(stmt, original.effectiveSubstatements()));
}
@Override
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
return EffectiveStatements.createCase(stmt.declared(), stmt.getArgument(),
- computeFlags(stmt, substatements), substatements, stmt.original(CaseSchemaNode.class));
+ computeFlags(stmt, substatements), substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
protected CaseEffectiveStatement createUndeclaredEffective(final Current<QName, CaseStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createCase(stmt.getArgument(), computeFlags(stmt, substatements),
- substatements, stmt.original(CaseSchemaNode.class));
+ return EffectiveStatements.createCase(stmt.getArgument(), computeFlags(stmt, substatements), substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
public ChoiceEffectiveStatement copyEffective(final Current<QName, ChoiceStatement> stmt,
final ChoiceEffectiveStatement original) {
return EffectiveStatements.copyChoice(original, stmt.getArgument(),
- computeFlags(stmt, original.effectiveSubstatements()), stmt.original(ChoiceSchemaNode.class));
+ computeFlags(stmt, original.effectiveSubstatements()));
}
@Override
try {
return EffectiveStatements.createChoice(stmt.declared(), stmt.getArgument(),
- computeFlags(stmt, substatements), substatements, defaultCase, stmt.original(ChoiceSchemaNode.class));
+ computeFlags(stmt, substatements), substatements, defaultCase);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
try {
return EffectiveStatements.createContainer(stmt.declared(), stmt.getArgument(),
- createFlags(stmt, substatements), substatements, stmt.original(ContainerSchemaNode.class));
+ createFlags(stmt, substatements), substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
public ContainerEffectiveStatement copyEffective(final Current<QName, ContainerStatement> stmt,
final ContainerEffectiveStatement original) {
return EffectiveStatements.copyContainer(original, stmt.getArgument(),
- createFlags(stmt, original.effectiveSubstatements()), stmt.original(ContainerSchemaNode.class));
+ createFlags(stmt, original.effectiveSubstatements()));
}
@Override
public LeafListEffectiveStatement copyEffective(final Current<QName, LeafListStatement> stmt,
final LeafListEffectiveStatement original) {
return EffectiveStatements.copyLeafList(original, stmt.getArgument(),
- computeFlags(stmt, original.effectiveSubstatements()), stmt.original(LeafListSchemaNode.class));
+ computeFlags(stmt, original.effectiveSubstatements()));
}
@Override
return EffectiveStatements.createLeafList(stmt.declared(), stmt.getArgument(),
computeFlags(stmt, substatements), substatements, defaultValues,
- EffectiveStmtUtils.createElementCountConstraint(substatements).orElse(null),
- stmt.original(LeafListSchemaNode.class));
+ EffectiveStmtUtils.createElementCountConstraint(substatements).orElse(null));
}
@Override
public LeafEffectiveStatement copyEffective(final Current<QName, LeafStatement> stmt,
final LeafEffectiveStatement original) {
return EffectiveStatements.copyLeaf(original, stmt.getArgument(),
- computeFlags(stmt, original.effectiveSubstatements()), stmt.original(LeafSchemaNode.class));
+ computeFlags(stmt, original.effectiveSubstatements()));
}
@Override
"Leaf '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
return EffectiveStatements.createLeaf(stmt.declared(), stmt.getArgument(), computeFlags(stmt, substatements),
- substatements, stmt.original(LeafSchemaNode.class));
+ substatements);
}
@Override
*/
package org.opendaylight.yangtools.yang.stmt;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
-import org.eclipse.jdt.annotation.Nullable;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(bazQName("data"));
assertFalse(data_g.isAddedByUses());
- assertFalse(data_u.equals(data_g));
- assertEquals(data_g, extractOriginal(data_u));
+ assertNotEquals(data_u, data_g);
final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(fooQName("how"));
assertIsAddedByUses(how_u, true);
final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(bazQName("how"));
assertIsAddedByUses(how_g, false);
assertEquals(2, how_g.getCases().size());
- assertFalse(how_u.equals(how_g));
- assertEquals(how_g, extractOriginal(how_u));
+ assertNotEquals(how_u, how_g);
final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(fooQName("address"));
assertEquals(Optional.of("1.2.3.4"), address_u.getType().getDefaultValue());
assertFalse(address_g.isAddedByUses());
assertEquals(Optional.empty(), address_g.getType().getDefaultValue());
assertEquals(Optional.of("Target IP address"), address_g.getDescription());
- assertFalse(address_g.getReference().isPresent());
+ assertEquals(Optional.empty(), address_g.getReference());
assertEquals(Optional.empty(), address_g.effectiveConfig());
- assertFalse(address_u.equals(address_g));
assertTrue(address_g.isMandatory());
- assertEquals(address_g, extractOriginal(address_u));
+ assertNotEquals(address_u, address_g);
final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(fooQName("port"));
assertIsAddedByUses(port_u, true);
final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(bazQName("port"));
assertIsAddedByUses(port_g, false);
- assertFalse(port_u.equals(port_g));
- assertEquals(port_g, extractOriginal(port_u));
+ assertNotEquals(port_u, port_g);
final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(fooQName("addresses"));
assertIsAddedByUses(addresses_u, true);
final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(bazQName("addresses"));
assertIsAddedByUses(addresses_g, false);
- assertFalse(addresses_u.equals(addresses_g));
- assertEquals(addresses_g, extractOriginal(addresses_u));
+ assertNotEquals(addresses_u, addresses_g);
// grouping defined by 'uses'
final Collection<? extends GroupingDefinition> groupings_u = destination.getGroupings();
final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(bazQName("data"));
assertFalse(data_g.isAddedByUses());
- assertFalse(data_u.equals(data_g));
- assertEquals(data_g, extractOriginal(data_u));
+ assertNotEquals(data_u, data_g);
final ChoiceSchemaNode how_u = (ChoiceSchemaNode) FOO.getDataChildByName(fooQName("how"));
assertIsAddedByUses(how_u, true);
final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(bazQName("how"));
assertIsAddedByUses(how_g, false);
- assertFalse(how_u.equals(how_g));
- assertEquals(how_g, extractOriginal(how_u));
+ assertNotEquals(how_u, how_g);
final LeafSchemaNode address_u = (LeafSchemaNode) FOO.getDataChildByName(fooQName("address"));
assertEquals(Optional.empty(), address_u.getType().getDefaultValue());
assertEquals(Optional.of("Target IP address"), address_g.getDescription());
assertFalse(address_g.getReference().isPresent());
assertEquals(Optional.empty(), address_g.effectiveConfig());
- assertFalse(address_u.equals(address_g));
- assertEquals(address_g, extractOriginal(address_u));
+ assertNotEquals(address_u, address_g);
final ContainerSchemaNode port_u = (ContainerSchemaNode) FOO.getDataChildByName(fooQName("port"));
assertIsAddedByUses(port_u, true);
final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(bazQName("port"));
assertIsAddedByUses(port_g, false);
- assertFalse(port_u.equals(port_g));
- assertEquals(port_g, extractOriginal(port_u));
+ assertNotEquals(port_u, port_g);
final ListSchemaNode addresses_u = (ListSchemaNode) FOO.getDataChildByName(fooQName("addresses"));
assertIsAddedByUses(addresses_u, true);
final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(bazQName("addresses"));
assertIsAddedByUses(addresses_g, false);
- assertFalse(addresses_u.equals(addresses_g));
- assertEquals(addresses_g, extractOriginal(addresses_u));
+ assertNotEquals(addresses_u, addresses_g);
// grouping defined by 'uses'
final Collection<? extends GroupingDefinition> groupings_u = FOO.getGroupings();
final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(
QName.create(namespace, "leaf-grouping-U"));
assertFalse(leafGroupingU.isAddedByUses());
- assertNull(extractOriginal(leafGroupingU));
for (final DataSchemaNode childNode : childNodes) {
if (!childNode.getQName().equals(leafGroupingU.getQName())) {
QName.create(namespace, "leaf-grouping-ZZ"));
assertFalse(leafZZinGZZ.isAddedByUses());
assertEquals(QName.create(expectedModule, "leaf-grouping-ZZ"), leafZZinGZZ.getQName());
-
- // TEST getOriginal from grouping-U
- assertEquals(gv.getDataChildByName(QName.create(namespace, "leaf-grouping-V")),
- extractOriginal(gu.getDataChildByName(QName.create(namespace, "leaf-grouping-V"))));
- containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(
- QName.create(namespace, "container-grouping-V"));
- assertEquals(gv.getDataChildByName(QName.create(namespace, "container-grouping-V")),
- extractOriginal(containerGroupingV));
- assertEquals(gx.getDataChildByName(QName.create(namespace, "leaf-grouping-X")),
- extractOriginal(containerGroupingV.getDataChildByName(QName.create(namespace, "leaf-grouping-X"))));
- assertEquals(gy.getDataChildByName(QName.create(namespace, "leaf-grouping-Y")),
- extractOriginal(containerGroupingV.getDataChildByName(QName.create(namespace, "leaf-grouping-Y"))));
-
- assertEquals(gz.getDataChildByName(QName.create(namespace, "leaf-grouping-Z")),
- extractOriginal(gu.getDataChildByName(QName.create(namespace, "leaf-grouping-Z"))));
- assertEquals(gzz.getDataChildByName(QName.create(namespace, "leaf-grouping-ZZ")),
- extractOriginal(gu.getDataChildByName(QName.create(namespace, "leaf-grouping-ZZ"))));
-
- // TEST getOriginal from grouping-V
- assertEquals(gz.getDataChildByName(QName.create(namespace, "leaf-grouping-Z")),
- extractOriginal(gv.getDataChildByName(QName.create(namespace, "leaf-grouping-Z"))));
- assertEquals(gzz.getDataChildByName(QName.create(namespace, "leaf-grouping-ZZ")),
- extractOriginal(gv.getDataChildByName(QName.create(namespace, "leaf-grouping-ZZ"))));
-
- // TEST getOriginal from grouping-X
- assertEquals(gy.getDataChildByName(QName.create(namespace, "leaf-grouping-Y")),
- extractOriginal(gx.getDataChildByName(QName.create(namespace, "leaf-grouping-Y"))));
}
@Test
}
}
}
-
- private static @Nullable DerivableSchemaNode<?> extractOriginal(final SchemaNode node) {
- assertThat(node, instanceOf(DerivableSchemaNode.class));
- return ((DerivableSchemaNode<?>) node).getOriginal().orElse(null);
- }
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import java.util.Objects;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CopyableNode;
public boolean canReuseCurrent(final Current<QName, D> copy, final Current<QName, D> current,
final Collection<? extends EffectiveStatement<?, ?>> substatements) {
return copy.effectiveConfig() == current.effectiveConfig()
- && super.canReuseCurrent(copy, current, substatements)
- // This weird quirk is needed for ... something somewhere
- && Objects.equals(copy.original(), current.original());
+ && super.canReuseCurrent(copy, current, substatements);
}
}
@Deprecated(since = "7.0.9", forRemoval = true)
@Nullable EffectiveStatement<?, ?> original();
- @Deprecated(since = "7.0.9", forRemoval = true)
- default <T> @Nullable T original(final @NonNull Class<T> type) {
- return type.cast(original());
- }
-
// FIXME: 8.0.0: this method should be moved to stmt.type in some shape or form
@NonNull QName argumentAsTypeQName();
Code Review / yangtools.git / commitdiff