import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
return delegate().getQName();
}
- @Override
- @Deprecated
- public final SchemaPath getPath() {
- return delegate().getPath();
- }
-
@Deprecated
@Override
public final boolean isAugmenting() {
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
return schemaNode.getQName();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return schemaNode.getPath();
- }
-
@Override
public Optional<String> getDescription() {
return schemaNode.getDescription();
return NAME;
}
- @Override
- @Deprecated
- default SchemaPath getPath() {
- return SchemaPath.ROOT;
- }
-
@Override
@Deprecated
default Status getStatus() {
* @return QName with the name of the schema node
*/
@NonNull QName getQName();
-
- /**
- * Returns the schema path of the instance of the type {@code SchemaNode}.
- *
- * <p>
- * The default implementation throws an {@link UnsupportedOperationException}.
- *
- * @return schema path of the schema node
- * @throws UnsupportedOperationException when the implementation does not support per-node unique paths
- * @deprecated The idea of identifying SchemaNodes through a global path does not work. There are two problems:
- * <ul>
- * <li>SchemaPath does not work because it does not discern namespaces, i.e. we do not known whether
- * the {@code QName} refers to a {@code grouping}, a {@code typedef} or a {@code container}.
- * </li>
- * <li>Such a path needs to be maintained by each SchemaNode and requires us to instantiate each
- * effective statement as a separate object (because {@link #getPath()} is effectively an
- * identity within a given {@link EffectiveModelContext}.
- * </li>
- * </ul>
- * An alternative method of exchanging pointers to schema nodes (well, statements, really), exists in
- * the form of {@link EffectiveStatementInference} and its ecosystem. This method is scheduled for
- * removal in the next major release.
- */
- @Deprecated(forRemoval = true)
- default @NonNull SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupported(this);
- }
}
+++ /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.model.api;
-
-import static com.google.common.base.Verify.verifyNotNull;
-
-import com.google.common.annotations.Beta;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.common.QName;
-
-@Beta
-@NonNullByDefault
-public final class SchemaNodeDefaults {
- private SchemaNodeDefaults() {
- // Hidden on purpose
- }
-
- /**
- * Report unsupported {@link SchemaNode#getPath()} implementation. This method is guaranteed to throw an
- * {@link UnsupportedOperationException}.
- *
- * @param impl {@code this} object of invoking implementation
- * @return Nothing
- * @throws NullPointerException if {@code impl} is null
- * @throws UnsupportedOperationException always
- * @see SchemaNode#getPath()
- */
- // FIXME: 8.0.0: consider deprecating this method
- public static SchemaPath throwUnsupported(final Object impl) {
- throw new UnsupportedOperationException(impl.getClass() + " does not support SchemaNode.getPath()");
- }
-
- /**
- * Report unsupported {@link SchemaNode#getPath()} implementation if provided path is null.
- *
- * @param impl {@code this} object of invoking implementation
- * @param path A schema path
- * @return {@code path} if non-null
- * @throws NullPointerException if {@code impl} is null
- * @throws UnsupportedOperationException if @{code path} is null
- * @see SchemaNode#getPath()
- */
- // FIXME: 8.0.0: consider deprecating this method
- public static SchemaPath throwUnsupportedIfNull(final Object impl, final @Nullable SchemaPath path) {
- return path != null ? path : throwUnsupported(impl);
- }
-
- /**
- * Extract {@link QName} from a path object.
- *
- * @param path Path handle
- * @return Extracted QName
- * @throws NullPointerException if {@code path} is null
- * @throws IllegalArgumentException if {@code path} is not supported
- */
- // FIXME: 8.0.0: consider deprecating this method
- public static QName extractQName(final Immutable path) {
- if (path instanceof QName) {
- return (QName) path;
- } else if (path instanceof SchemaPath) {
- return verifyNotNull(((SchemaPath) path).getLastComponent());
- } else {
- throw new IllegalArgumentException("Unhandled object " + path);
- }
- }
-
- /**
- * Extract {@link SchemaPath} from a path object.
- *
- * @param impl Implementation object
- * @param path Path handle
- * @return Extracted SchemaPath
- * @throws UnsupportedOperationException if {@code path} does not hold a SchemaPath
- */
- // FIXME: 8.0.0: consider deprecating this method
- public static SchemaPath extractPath(final Object impl, final Immutable path) {
- return path instanceof SchemaPath ? (SchemaPath) path : SchemaNodeDefaults.throwUnsupported(impl);
- }
-}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
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.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
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;
// Hidden on purpose
}
- public static ActionEffectiveStatement copyAction(final ActionEffectiveStatement original, final Immutable path,
+ public static ActionEffectiveStatement copyAction(final ActionEffectiveStatement original, final QName argument,
final int flags) {
checkArgument(original instanceof ActionEffectiveStatementImpl, "Unsupported original %s", original);
- return new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, path, flags);
+ return new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, argument, flags);
}
- public static ActionEffectiveStatement createAction(final ActionStatement declared, final Immutable path,
+ public static ActionEffectiveStatement createAction(final ActionStatement declared, final QName argument,
final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
throws SubstatementIndexingException {
- return new ActionEffectiveStatementImpl(declared, path, flags, substatements);
+ return new ActionEffectiveStatementImpl(declared, argument, flags, substatements);
}
- public static AnydataEffectiveStatement copyAnydata(final AnydataEffectiveStatement original, final Immutable path,
+ public static AnydataEffectiveStatement copyAnydata(final AnydataEffectiveStatement original, final QName argument,
final int flags, final @Nullable AnydataSchemaNode newOriginal) {
if (original instanceof RegularAnydataEffectiveStatement) {
- return new RegularAnydataEffectiveStatement((RegularAnydataEffectiveStatement) original, path, flags,
+ return new RegularAnydataEffectiveStatement((RegularAnydataEffectiveStatement) original, argument, flags,
newOriginal);
} else if (original instanceof EmptyAnydataEffectiveStatement) {
- return new EmptyAnydataEffectiveStatement((EmptyAnydataEffectiveStatement) original, path, flags,
+ return new EmptyAnydataEffectiveStatement((EmptyAnydataEffectiveStatement) original, argument, flags,
newOriginal);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
}
- public static AnydataEffectiveStatement createAnydata(final AnydataStatement declared, final Immutable path,
+ 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, path, flags, original)
- : new RegularAnydataEffectiveStatement(declared, path, flags, original, substatements);
+ return substatements.isEmpty() ? new EmptyAnydataEffectiveStatement(declared, argument, flags, original)
+ : new RegularAnydataEffectiveStatement(declared, argument, flags, original, substatements);
}
- public static AnyxmlEffectiveStatement copyAnyxml(final AnyxmlEffectiveStatement original, final Immutable path,
+ public static AnyxmlEffectiveStatement copyAnyxml(final AnyxmlEffectiveStatement original, final QName argument,
final int flags, final @Nullable AnyxmlSchemaNode newOriginal) {
if (original instanceof RegularAnyxmlEffectiveStatement) {
- return new RegularAnyxmlEffectiveStatement((RegularAnyxmlEffectiveStatement) original, path, flags,
+ return new RegularAnyxmlEffectiveStatement((RegularAnyxmlEffectiveStatement) original, argument, flags,
newOriginal);
} else if (original instanceof EmptyAnyxmlEffectiveStatement) {
- return new EmptyAnyxmlEffectiveStatement((EmptyAnyxmlEffectiveStatement) original, path, flags,
+ return new EmptyAnyxmlEffectiveStatement((EmptyAnyxmlEffectiveStatement) original, argument, flags,
newOriginal);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
}
- public static AnyxmlEffectiveStatement createAnyxml(final AnyxmlStatement declared, final Immutable path,
+ 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, path, flags, original)
- : new RegularAnyxmlEffectiveStatement(declared, path, flags, original, substatements);
+ return substatements.isEmpty() ? new EmptyAnyxmlEffectiveStatement(declared, argument, flags, original)
+ : new RegularAnyxmlEffectiveStatement(declared, argument, flags, original, substatements);
}
public static ArgumentEffectiveStatement createArgument(final ArgumentStatement declared,
: new RegularBitEffectiveStatement(declared, substatements);
}
- public static CaseEffectiveStatement copyCase(final CaseEffectiveStatement original,
- final Immutable path, final int flags, final @Nullable CaseSchemaNode newOriginal) {
+ public static CaseEffectiveStatement copyCase(final CaseEffectiveStatement original, final QName argument,
+ final int flags, final @Nullable CaseSchemaNode newOriginal) {
if (original instanceof DeclaredCaseEffectiveStatement) {
- return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, path, flags,
+ return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, argument, flags,
newOriginal);
} else if (original instanceof UndeclaredCaseEffectiveStatement) {
- return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, path, flags,
+ return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, argument, flags,
newOriginal);
} else {
throw new IllegalArgumentException("Unsupported origin " + original);
}
}
- public static CaseEffectiveStatement createCase(final Immutable path,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable CaseSchemaNode original) {
- return new UndeclaredCaseEffectiveStatement(substatements, path, flags, 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);
}
- public static CaseEffectiveStatement createCase(final CaseStatement declared, final Immutable path,
+ 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, path, flags, original);
+ return new DeclaredCaseEffectiveStatement(declared, substatements, argument, flags, original);
}
public static ChoiceEffectiveStatement copyChoice(final ChoiceEffectiveStatement original,
- final Immutable path, final int flags, final @Nullable ChoiceSchemaNode newOriginal) {
+ final QName argument, final int flags, final @Nullable ChoiceSchemaNode newOriginal) {
checkArgument(original instanceof ChoiceEffectiveStatementImpl, "Unsupported original %s", original);
- return new ChoiceEffectiveStatementImpl((ChoiceEffectiveStatementImpl) original, path, flags, newOriginal);
+ return new ChoiceEffectiveStatementImpl((ChoiceEffectiveStatementImpl) original, argument, flags, newOriginal);
}
- public static ChoiceEffectiveStatement createChoice(final ChoiceStatement declared, final Immutable path,
+ 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, path, flags, defaultCase, original);
+ return new ChoiceEffectiveStatementImpl(declared, substatements, argument, flags, defaultCase, original);
}
public static ConfigEffectiveStatement createConfig(final boolean argument) {
}
public static ContainerEffectiveStatement copyContainer(final ContainerEffectiveStatement original,
- final Immutable path, final int flags, final @Nullable ContainerSchemaNode orig) {
+ final QName argument, final int flags, final @Nullable ContainerSchemaNode orig) {
checkArgument(original instanceof ContainerEffectiveStatementImpl, "Unsupported original %s", original);
- return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original, path, flags, orig);
+ return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original, argument, flags, orig);
}
- public static ContainerEffectiveStatement createContainer(final ContainerStatement declared, final Immutable path,
+ 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, path, flags, original);
+ return new ContainerEffectiveStatementImpl(declared, substatements, argument, flags, original);
}
public static DefaultEffectiveStatement createDefault(final DefaultStatement declared,
}
public static ExtensionEffectiveStatement createExtension(final ExtensionStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final @Nullable SchemaPath schemaPath) {
- return new ExtensionEffectiveStatementImpl(declared, substatements, schemaPath);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new ExtensionEffectiveStatementImpl(declared, substatements);
}
- public static FeatureEffectiveStatement createFeature(final FeatureStatement declared, final Immutable path,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return substatements.isEmpty() ? new EmptyFeatureEffectiveStatement(declared, path, flags)
- : new RegularFeatureEffectiveStatement(declared, path, flags, substatements);
+ public static FeatureEffectiveStatement createFeature(final FeatureStatement declared, final int flags,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyFeatureEffectiveStatement(declared, flags)
+ : new RegularFeatureEffectiveStatement(declared, flags, substatements);
}
public static FractionDigitsEffectiveStatement createFractionDigits(final FractionDigitsStatement declared) {
}
public static GroupingEffectiveStatement createGrouping(final GroupingStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags) throws SubstatementIndexingException {
- return new GroupingEffectiveStatementImpl(declared, substatements, path, flags);
+ return new GroupingEffectiveStatementImpl(declared, substatements, argument, flags);
}
public static IfFeatureEffectiveStatement createIfFeature(final IfFeatureStatement declared,
: new RegularIfFeatureEffectiveStatement(declared, substatements);
}
- public static IdentityEffectiveStatement createIdentity(final IdentityStatement declared, final Immutable path) {
- return new EmptyIdentityEffectiveStatement(declared, path);
+ public static IdentityEffectiveStatement createIdentity(final IdentityStatement declared) {
+ return new EmptyIdentityEffectiveStatement(declared);
}
- public static IdentityEffectiveStatement createIdentity(final IdentityStatement declared, final Immutable path,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ public static IdentityEffectiveStatement createIdentity(final IdentityStatement declared, final int flags,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableSet<IdentitySchemaNode> baseIdentities) {
- return new RegularIdentityEffectiveStatement(declared, path, flags, substatements, baseIdentities);
+ return new RegularIdentityEffectiveStatement(declared, flags, substatements, baseIdentities);
}
public static ImportEffectiveStatement createImport(final ImportStatement declared,
: new RegularIncludeEffectiveStatement(declared, substatements);
}
- public static InputEffectiveStatement copyInput(final InputEffectiveStatement original, final Immutable path,
+ public static InputEffectiveStatement copyInput(final InputEffectiveStatement original, final QName argument,
final int flags) {
if (original instanceof DeclaredInputEffectiveStatement) {
- return new DeclaredInputEffectiveStatement((DeclaredInputEffectiveStatement) original, path, flags);
+ return new DeclaredInputEffectiveStatement((DeclaredInputEffectiveStatement) original, argument, flags);
} else if (original instanceof UndeclaredInputEffectiveStatement) {
- return new UndeclaredInputEffectiveStatement((UndeclaredInputEffectiveStatement) original, path, flags);
+ return new UndeclaredInputEffectiveStatement((UndeclaredInputEffectiveStatement) original, argument, flags);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
}
- public static InputEffectiveStatement createInput(final Immutable path, final int flags,
+ public static InputEffectiveStatement createInput(final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
throws SubstatementIndexingException {
- return new UndeclaredInputEffectiveStatement(substatements, path, flags);
+ return new UndeclaredInputEffectiveStatement(substatements, argument, flags);
}
- public static InputEffectiveStatement createInput(final InputStatement declared, final Immutable path,
+ public static InputEffectiveStatement createInput(final InputStatement declared, final QName argument,
final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
throws SubstatementIndexingException {
- return new DeclaredInputEffectiveStatement(declared, substatements, path, flags);
+ return new DeclaredInputEffectiveStatement(declared, substatements, argument, flags);
}
public static KeyEffectiveStatement createKey(final KeyStatement declared, final Set<QName> argument,
: new RegularForeignKeyEffectiveStatement(declared, argument, substatements);
}
- public static LeafEffectiveStatement copyLeaf(final LeafEffectiveStatement original, final Immutable path,
+ public static LeafEffectiveStatement copyLeaf(final LeafEffectiveStatement original, final QName argument,
final int flags, final @Nullable LeafSchemaNode newOriginal) {
checkArgument(original instanceof AbstractLeafEffectiveStatement, "Unsupported original %s", original);
- return new RegularLeafEffectiveStatement((AbstractLeafEffectiveStatement) original, path, flags, newOriginal);
+ return new RegularLeafEffectiveStatement((AbstractLeafEffectiveStatement) original, argument, flags,
+ newOriginal);
}
- public static LeafEffectiveStatement createLeaf(final LeafStatement declared, final Immutable path,
- final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ 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, path, flags, substatements)
- : new RegularLeafEffectiveStatement(declared, path, flags, substatements, original);
+ return original == null ? new EmptyLeafEffectiveStatement(declared, argument, flags, substatements)
+ : new RegularLeafEffectiveStatement(declared, argument, flags, substatements, original);
}
public static LengthEffectiveStatement createLength(final LengthStatement declared,
}
public static NotificationEffectiveStatement copyNotification(final NotificationEffectiveStatement original,
- final Immutable path, final int flags) {
+ final QName argument, final int flags) {
checkArgument(original instanceof NotificationEffectiveStatementImpl, "Unsupported original %s", original);
- return new NotificationEffectiveStatementImpl((NotificationEffectiveStatementImpl) original, path, flags);
+ return new NotificationEffectiveStatementImpl((NotificationEffectiveStatementImpl) original, argument, flags);
}
public static NotificationEffectiveStatement createNotification(final NotificationStatement declared,
- final Immutable path, final int flags,
+ final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
throws SubstatementIndexingException {
- return new NotificationEffectiveStatementImpl(declared, substatements, path, flags);
+ return new NotificationEffectiveStatementImpl(declared, substatements, argument, flags);
}
- public static OutputEffectiveStatement copyOutput(final OutputEffectiveStatement original, final Immutable path,
+ public static OutputEffectiveStatement copyOutput(final OutputEffectiveStatement original, final QName argument,
final int flags) {
if (original instanceof DeclaredOutputEffectiveStatement) {
- return new DeclaredOutputEffectiveStatement((DeclaredOutputEffectiveStatement) original, path, flags);
+ return new DeclaredOutputEffectiveStatement((DeclaredOutputEffectiveStatement) original, argument, flags);
} else if (original instanceof UndeclaredOutputEffectiveStatement) {
- return new UndeclaredOutputEffectiveStatement((UndeclaredOutputEffectiveStatement) original, path, flags);
+ return new UndeclaredOutputEffectiveStatement((UndeclaredOutputEffectiveStatement) original, argument,
+ flags);
} else {
throw new IllegalArgumentException("Unsupported original " + original);
}
}
- public static OutputEffectiveStatement createOutput(final Immutable path, final int flags,
+ public static OutputEffectiveStatement createOutput(final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
throws SubstatementIndexingException {
- return new UndeclaredOutputEffectiveStatement(substatements, path, flags);
+ return new UndeclaredOutputEffectiveStatement(substatements, argument, flags);
}
- public static OutputEffectiveStatement createOutput(final OutputStatement declared, final Immutable path,
+ public static OutputEffectiveStatement createOutput(final OutputStatement declared, final QName argument,
final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
throws SubstatementIndexingException {
- return new DeclaredOutputEffectiveStatement(declared, substatements, path, flags);
+ return new DeclaredOutputEffectiveStatement(declared, substatements, argument, flags);
}
public static OrderedByEffectiveStatement createOrderedBy(final OrderedByStatement declared) {
}
public static RpcEffectiveStatement createRpc(final RpcStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
- final int flags) throws SubstatementIndexingException {
- return new RpcEffectiveStatementImpl(declared, substatements, path, flags);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
+ final int flags) throws SubstatementIndexingException {
+ return new RpcEffectiveStatementImpl(declared, substatements, argument, flags);
}
public static StatusEffectiveStatement createStatus(final StatusStatement declared) {
: new RegularStatusEffectiveStatement(declared, substatements);
}
- public static TypedefEffectiveStatement createTypedef(final TypedefStatement declared,
- final Immutable path, final int flags,
+ public static TypedefEffectiveStatement createTypedef(final TypedefStatement declared, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new TypedefEffectiveStatementImpl(declared, path, flags, substatements);
+ return new TypedefEffectiveStatementImpl(declared, flags, substatements);
}
public static UnitsEffectiveStatement createUnits(final UnitsStatement declared,
*/
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.base.MoreObjects;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.SchemaNodeMixin;
abstract class AbstractIdentityEffectiveStatement extends DefaultArgument<QName, IdentityStatement>
- implements IdentityEffectiveStatement, IdentitySchemaNode, SchemaNodeMixin<QName, IdentityStatement> {
- private final @NonNull Immutable path;
-
- AbstractIdentityEffectiveStatement(final IdentityStatement declared, final Immutable path) {
+ implements IdentityEffectiveStatement, IdentitySchemaNode, SchemaNodeMixin<IdentityStatement> {
+ AbstractIdentityEffectiveStatement(final IdentityStatement declared) {
super(declared);
- this.path = requireNonNull(path);
- }
-
- @Override
- public final Immutable pathObject() {
- return path;
}
@Override
@Override
public final String toString() {
- return MoreObjects.toStringHelper(this).add("qname", getQName()).add("path", path).toString();
+ return MoreObjects.toStringHelper(this).add("qname", getQName()).toString();
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
public abstract class AbstractLeafEffectiveStatement
extends AbstractDeclaredEffectiveStatement.Default<QName, LeafStatement>
implements LeafEffectiveStatement, LeafSchemaNode, DerivableSchemaNode,
- DataSchemaNodeMixin<QName, LeafStatement>, MandatoryMixin<QName, LeafStatement>,
+ DataSchemaNodeMixin<LeafStatement>, MandatoryMixin<QName, LeafStatement>,
MustConstraintMixin<QName, LeafStatement> {
private final @NonNull Object substatements;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final @NonNull TypeDefinition<?> type;
private final int flags;
- AbstractLeafEffectiveStatement(final LeafStatement declared, final Immutable path, final int flags,
+ AbstractLeafEffectiveStatement(final LeafStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.substatements = maskList(substatements);
this.flags = flags;
// TODO: lazy instantiation?
this.type = buildType();
}
- AbstractLeafEffectiveStatement(final AbstractLeafEffectiveStatement original, final Immutable path,
+ AbstractLeafEffectiveStatement(final AbstractLeafEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.substatements = original.substatements;
this.flags = flags;
// FIXME: share with original?
@Override
public final QName argument() {
- return getQName();
- }
-
- @Override
- public final Immutable pathObject() {
- return path;
+ return argument;
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
extends WithSubstatements<QName, ActionStatement, ActionEffectiveStatement>
implements ActionDefinition, ActionEffectiveStatement, OperationDefinitionMixin<ActionStatement>,
CopyableMixin<QName, ActionStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
- public ActionEffectiveStatementImpl(final ActionStatement declared, final Immutable path, final int flags,
+ public ActionEffectiveStatementImpl(final ActionStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
- public ActionEffectiveStatementImpl(final ActionEffectiveStatementImpl original, final Immutable path,
+ public ActionEffectiveStatementImpl(final ActionEffectiveStatementImpl original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
*/
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.MustConstraintMixin;
interface CaseEffectiveStatementMixin extends CaseEffectiveStatement, CaseSchemaNode, DerivableSchemaNode,
- DataSchemaNodeMixin<QName, CaseStatement>, DocumentedNodeMixin.WithStatus<QName, CaseStatement>,
+ DataSchemaNodeMixin<CaseStatement>, DocumentedNodeMixin.WithStatus<QName, CaseStatement>,
DataNodeContainerMixin<QName, CaseStatement>, MustConstraintMixin<QName, CaseStatement>,
AugmentationTargetMixin<QName, CaseStatement> {
-
@Override
- default @NonNull QName argument() {
- return getQName();
+ default QName getQName() {
+ return argument();
}
}
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
public final class ChoiceEffectiveStatementImpl
extends WithSubstatements<QName, ChoiceStatement, ChoiceEffectiveStatement>
implements ChoiceEffectiveStatement, ChoiceSchemaNode, DerivableSchemaNode,
- DataSchemaNodeMixin<QName, ChoiceStatement>, AugmentationTargetMixin<QName, ChoiceStatement>,
+ DataSchemaNodeMixin<ChoiceStatement>, AugmentationTargetMixin<QName, ChoiceStatement>,
MandatoryMixin<QName, ChoiceStatement> {
private final CaseSchemaNode defaultCase;
private final ChoiceSchemaNode original;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public ChoiceEffectiveStatementImpl(final ChoiceStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
- final int flags, final @Nullable CaseSchemaNode defaultCase,
- final @Nullable ChoiceSchemaNode original) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
+ final int flags, final @Nullable CaseSchemaNode defaultCase, final @Nullable ChoiceSchemaNode original) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.defaultCase = defaultCase;
this.original = original;
}
- public ChoiceEffectiveStatementImpl(final ChoiceEffectiveStatementImpl origEffective, final Immutable path,
+ public ChoiceEffectiveStatementImpl(final ChoiceEffectiveStatementImpl origEffective, final QName argument,
final int flags, final ChoiceSchemaNode newOriginal) {
super(origEffective);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.defaultCase = origEffective.defaultCase;
this.original = newOriginal;
}
@Override
- public @NonNull QName argument() {
- return getQName();
- }
-
- @Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
@Override
public String toString() {
- return ChoiceEffectiveStatementImpl.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
+ return ChoiceEffectiveStatementImpl.class.getSimpleName() + "[" + "qname=" + argument + "]";
}
}
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public final class ContainerEffectiveStatementImpl
extends WithSubstatements<QName, ContainerStatement, ContainerEffectiveStatement>
implements ContainerEffectiveStatement, ContainerSchemaNode, DerivableSchemaNode,
- DataSchemaNodeMixin<QName, ContainerStatement>, DataNodeContainerMixin<QName, ContainerStatement>,
+ DataSchemaNodeMixin<ContainerStatement>, DataNodeContainerMixin<QName, ContainerStatement>,
ActionNodeContainerMixin<QName, ContainerStatement>,
ActionNodeContainerCompat<QName, ContainerStatement, ContainerEffectiveStatement>,
NotificationNodeContainerMixin<QName, ContainerStatement>,
AugmentationTargetMixin<QName, ContainerStatement> {
private final int flags;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final @Nullable ContainerSchemaNode original;
public ContainerEffectiveStatementImpl(final ContainerStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags, final @Nullable ContainerSchemaNode original) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.original = original;
this.flags = flags;
}
- public ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective, final Immutable path,
+ public ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective, final QName argument,
final int flags, final @Nullable ContainerSchemaNode original) {
super(origEffective);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.original = original;
this.flags = flags;
}
@Override
public QName argument() {
- return getQName();
- }
-
- @Override
- public Immutable pathObject() {
- return path;
+ return argument;
}
@Override
@Override
public String toString() {
- return "container " + getQName().getLocalName();
+ return "container " + argument.getLocalName();
}
}
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public final class DeclaredCaseEffectiveStatement
extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement> implements CaseEffectiveStatementMixin {
private final CaseSchemaNode original;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public DeclaredCaseEffectiveStatement(final CaseStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags, final @Nullable CaseSchemaNode original) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = original;
}
- public DeclaredCaseEffectiveStatement(final DeclaredCaseEffectiveStatement origEffective, final Immutable path,
+ public DeclaredCaseEffectiveStatement(final DeclaredCaseEffectiveStatement origEffective, final QName argument,
final int flags, final @Nullable CaseSchemaNode original) {
super(origEffective);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = original;
}
@Override
- public int flags() {
- return flags;
+ public QName argument() {
+ return argument;
}
@Override
- public Immutable pathObject() {
- return path;
+ public int flags() {
+ return flags;
}
@Override
@Override
public String toString() {
- return DeclaredCaseEffectiveStatement.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
+ return DeclaredCaseEffectiveStatement.class.getSimpleName() + "[" + "qname=" + argument + "]";
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
public final class DeclaredInputEffectiveStatement
extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public DeclaredInputEffectiveStatement(final InputStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
- public DeclaredInputEffectiveStatement(final DeclaredInputEffectiveStatement original, final Immutable path,
+ public DeclaredInputEffectiveStatement(final DeclaredInputEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
public final class DeclaredOutputEffectiveStatement
extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public DeclaredOutputEffectiveStatement(final OutputStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
- public DeclaredOutputEffectiveStatement(final DeclaredOutputEffectiveStatement original, final Immutable path,
+ public DeclaredOutputEffectiveStatement(final DeclaredOutputEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
public class EmptyAnydataEffectiveStatement extends Default<QName, AnydataStatement>
implements AnydataEffectiveStatement, AnydataSchemaNode, OpaqueDataSchemaNodeMixin<AnydataStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final AnydataSchemaNode original;
private final int flags;
- public EmptyAnydataEffectiveStatement(final AnydataStatement declared, final Immutable path, final int flags,
+ public EmptyAnydataEffectiveStatement(final AnydataStatement declared, final QName argument, final int flags,
final @Nullable AnydataSchemaNode original) {
super(declared);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = original;
}
- public EmptyAnydataEffectiveStatement(final EmptyAnydataEffectiveStatement original, final Immutable path,
+ public EmptyAnydataEffectiveStatement(final EmptyAnydataEffectiveStatement original, final QName argument,
final int flags, final @Nullable AnydataSchemaNode newOriginal) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = newOriginal;
}
@Override
- public final Immutable pathObject() {
- return path;
+ public final QName argument() {
+ return argument;
}
@Override
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
public class EmptyAnyxmlEffectiveStatement extends Default<QName, AnyxmlStatement>
implements AnyxmlEffectiveStatement, AnyxmlSchemaNode, OpaqueDataSchemaNodeMixin<AnyxmlStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final AnyxmlSchemaNode original;
private final int flags;
- public EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final Immutable path, final int flags,
+ public EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final QName argument, final int flags,
final @Nullable AnyxmlSchemaNode original) {
super(declared);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = original;
}
- public EmptyAnyxmlEffectiveStatement(final EmptyAnyxmlEffectiveStatement original, final Immutable path,
+ public EmptyAnyxmlEffectiveStatement(final EmptyAnyxmlEffectiveStatement original, final QName argument,
final int flags, final @Nullable AnyxmlSchemaNode newOriginal) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = newOriginal;
}
@Override
- public final Immutable pathObject() {
- return path;
+ public final QName argument() {
+ return argument;
}
@Override
@Override
public final String toString() {
- return MoreObjects.toStringHelper(this).add("qname", getQName()).toString();
+ return MoreObjects.toStringHelper(this).add("qname", argument).toString();
}
}
*/
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
-import static java.util.Objects.requireNonNull;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
-import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.Default;
+import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.SchemaNodeMixin;
-public class EmptyFeatureEffectiveStatement extends Default<QName, FeatureStatement>
- implements FeatureDefinition, FeatureEffectiveStatement, SchemaNodeMixin<QName, FeatureStatement> {
- private final @NonNull Immutable path;
+public class EmptyFeatureEffectiveStatement extends DefaultArgument<QName, FeatureStatement>
+ implements FeatureDefinition, FeatureEffectiveStatement, SchemaNodeMixin<FeatureStatement> {
private final int flags;
- public EmptyFeatureEffectiveStatement(final FeatureStatement declared, final Immutable path, final int flags) {
+ public EmptyFeatureEffectiveStatement(final FeatureStatement declared, final int flags) {
super(declared);
- this.path = requireNonNull(path);
this.flags = flags;
}
return flags;
}
- @Override
- public final @NonNull QName argument() {
- return getQName();
- }
-
- @Override
- @Deprecated
- public final Immutable pathObject() {
- return path;
- }
-
@Override
public final FeatureEffectiveStatement asEffectiveStatement() {
return this;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
public final class EmptyIdentityEffectiveStatement extends AbstractIdentityEffectiveStatement {
private static final int CURRENT_FLAGS = new FlagsBuilder().setStatus(Status.CURRENT).toFlags();
- public EmptyIdentityEffectiveStatement(final IdentityStatement declared, final Immutable path) {
- super(declared, path);
+ public EmptyIdentityEffectiveStatement(final IdentityStatement declared) {
+ super(declared);
}
@Override
import com.google.common.collect.ImmutableList;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
+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 Immutable path, final int flags,
+ public EmptyLeafEffectiveStatement(final LeafStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, path, flags, substatements);
- }
-
- EmptyLeafEffectiveStatement(final EmptyLeafEffectiveStatement original, final Immutable path, final int flags) {
- super(original, path, flags);
+ // FIXME: this seems to imply that argument.equals(declared.argument()) and we could save a field
+ super(declared, argument, flags, substatements);
}
@Override
import com.google.common.collect.ImmutableList;
import java.util.ArrayDeque;
import java.util.Deque;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentEffectiveStatement;
private static final RecursionDetector TOSTRING_DETECTOR = new RecursionDetector();
- private final @Nullable SchemaPath path;
private final Object substatements;
public ExtensionEffectiveStatementImpl(final ExtensionStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
this.substatements = maskList(substatements);
- this.path = path;
}
@Override
return argument();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public String getArgument() {
return findFirstEffectiveSubstatementArgument(ArgumentEffectiveStatement.class)
return ExtensionEffectiveStatementImpl.class.getSimpleName() + "["
+ "argument=" + getArgument()
+ ", qname=" + getQName()
- + ", schemaPath=" + path
+ ", yin=" + isYinElement()
+ ", extensionSchemaNodes=" + getUnknownSchemaNodes()
+ "]";
return ExtensionEffectiveStatementImpl.class.getSimpleName() + "["
+ "argument=" + getArgument()
+ ", qname=" + getQName()
- + ", schemaPath=" + path
+ ", yin=" + isYinElement()
+ " <RECURSIVE> ]";
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
public final class GroupingEffectiveStatementImpl
extends WithSubstatements<QName, GroupingStatement, GroupingEffectiveStatement>
implements GroupingDefinition, GroupingEffectiveStatement,
- DataNodeContainerMixin<QName, GroupingStatement>,
- SchemaNodeMixin<QName, GroupingStatement>, ActionNodeContainerMixin<QName, GroupingStatement>,
+ DataNodeContainerMixin<QName, GroupingStatement>, SchemaNodeMixin<GroupingStatement>,
+ ActionNodeContainerMixin<QName, GroupingStatement>,
NotificationNodeContainerMixin<QName, GroupingStatement>, AddedByUsesMixin<QName, GroupingStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public GroupingEffectiveStatementImpl(final GroupingStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
return flags;
}
- @Override
- public Immutable pathObject() {
- return path;
- }
-
@Override
public QName argument() {
- return getQName();
+ return argument;
}
@Override
@Override
public String toString() {
- return GroupingEffectiveStatementImpl.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
+ return GroupingEffectiveStatementImpl.class.getSimpleName() + "[" + "qname=" + argument + "]";
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
public final class NotificationEffectiveStatementImpl
extends WithSubstatements<QName, NotificationStatement, NotificationEffectiveStatement>
implements NotificationDefinition, NotificationEffectiveStatement,
- SchemaNodeMixin<QName, NotificationStatement>, DataNodeContainerMixin<QName, NotificationStatement>,
+ SchemaNodeMixin<NotificationStatement>, DataNodeContainerMixin<QName, NotificationStatement>,
AugmentationTargetMixin<QName, NotificationStatement>, CopyableMixin<QName, NotificationStatement>,
MustConstraintMixin<QName, NotificationStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public NotificationEffectiveStatementImpl(final NotificationStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Immutable path,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
final int flags) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
- public NotificationEffectiveStatementImpl(final NotificationEffectiveStatementImpl original, final Immutable path,
+ public NotificationEffectiveStatementImpl(final NotificationEffectiveStatementImpl original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
public QName argument() {
- return getQName();
+ return argument;
}
@Override
return flags;
}
- @Override
- public Immutable pathObject() {
- return path;
- }
-
@Override
public NotificationEffectiveStatement asEffectiveStatement() {
return this;
@Override
public String toString() {
- return NotificationEffectiveStatementImpl.class.getSimpleName() + "[qname=" + getQName() + ", path=" + path
- + "]";
+ return NotificationEffectiveStatementImpl.class.getSimpleName() + "[qname=" + argument + "]";
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
+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;
public final class RegularAnydataEffectiveStatement extends EmptyAnydataEffectiveStatement {
private final @NonNull Object substatements;
- public RegularAnydataEffectiveStatement(final AnydataStatement declared, final Immutable path, final int flags,
+ public RegularAnydataEffectiveStatement(final AnydataStatement declared, final QName argument, final int flags,
final @Nullable AnydataSchemaNode original,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, path, flags, original);
+ super(declared, argument, flags, original);
this.substatements = maskList(substatements);
}
- public RegularAnydataEffectiveStatement(final RegularAnydataEffectiveStatement original, final Immutable path,
+ public RegularAnydataEffectiveStatement(final RegularAnydataEffectiveStatement original, final QName argument,
final int flags, final @Nullable AnydataSchemaNode newOriginal) {
- super(original, path, flags, newOriginal);
+ super(original, argument, flags, newOriginal);
this.substatements = original.substatements;
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
+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;
public final class RegularAnyxmlEffectiveStatement extends EmptyAnyxmlEffectiveStatement {
private final @NonNull Object substatements;
- public RegularAnyxmlEffectiveStatement(final AnyxmlStatement declared, final Immutable path, final int flags,
+ public RegularAnyxmlEffectiveStatement(final AnyxmlStatement declared, final QName argument, final int flags,
final @Nullable AnyxmlSchemaNode original,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, path, flags, original);
+ super(declared, argument, flags, original);
this.substatements = maskList(substatements);
}
- public RegularAnyxmlEffectiveStatement(final RegularAnyxmlEffectiveStatement original, final Immutable path,
+ public RegularAnyxmlEffectiveStatement(final RegularAnyxmlEffectiveStatement original, final QName argument,
final int flags, final @Nullable AnyxmlSchemaNode newOriginal) {
- super(original, path, flags, newOriginal);
+ super(original, argument, flags, newOriginal);
this.substatements = original.substatements;
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
public final class RegularFeatureEffectiveStatement extends EmptyFeatureEffectiveStatement {
private final @NonNull Object substatements;
- public RegularFeatureEffectiveStatement(final FeatureStatement declared, final Immutable path, final int flags,
+ public RegularFeatureEffectiveStatement(final FeatureStatement declared, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, path, flags);
+ super(declared, flags);
this.substatements = maskList(substatements);
}
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
private final @NonNull Object substatements;
private final int flags;
- public RegularIdentityEffectiveStatement(final IdentityStatement declared, final Immutable path, final int flags,
+ public RegularIdentityEffectiveStatement(final IdentityStatement declared, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableSet<? extends IdentitySchemaNode> baseIdentities) {
- super(declared, path);
+ super(declared);
this.flags = flags;
this.substatements = maskList(substatements);
this.baseIdentities = maskSet(baseIdentities);
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
+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 Immutable path, final int flags,
+ public RegularLeafEffectiveStatement(final LeafStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final LeafSchemaNode original) {
- super(declared, path, flags, substatements);
+ super(declared, argument, flags, substatements);
this.original = original;
}
- public RegularLeafEffectiveStatement(final AbstractLeafEffectiveStatement originalEffective, final Immutable path,
+ public RegularLeafEffectiveStatement(final AbstractLeafEffectiveStatement originalEffective, final QName argument,
final int flags, final LeafSchemaNode original) {
- super(originalEffective, path, flags);
+ super(originalEffective, argument, flags);
this.original = original;
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
public final class RpcEffectiveStatementImpl extends WithSubstatements<QName, RpcStatement, RpcEffectiveStatement>
implements RpcDefinition, RpcEffectiveStatement, OperationDefinitionMixin<RpcStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public RpcEffectiveStatementImpl(final RpcStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final Immutable path, final int flags) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
+ final int flags) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
*/
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.collect.ImmutableList;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.ri.type.DerivedTypeBuilder;
import org.opendaylight.yangtools.yang.model.ri.type.DerivedTypes;
-import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.Default;
+import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.SchemaNodeMixin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class TypedefEffectiveStatementImpl extends Default<QName, TypedefStatement>
- implements TypedefEffectiveStatement, SchemaNodeMixin<QName, TypedefStatement> {
+public final class TypedefEffectiveStatementImpl extends WithSubstatements<QName, TypedefStatement>
+ implements TypedefEffectiveStatement, SchemaNodeMixin<TypedefStatement> {
private static final Logger LOG = LoggerFactory.getLogger(TypedefEffectiveStatementImpl.class);
private static final VarHandle TYPE_DEFINITION;
}
}
- private final @NonNull Object substatements;
- private final @NonNull Immutable path;
private final int flags;
// Accessed via TYPE_DEFINITION
@SuppressWarnings("unused")
private volatile ProxyTypeEffectiveStatement typeStatement;
- public TypedefEffectiveStatementImpl(final TypedefStatement declared, final Immutable path, final int flags,
+ public TypedefEffectiveStatementImpl(final TypedefStatement declared, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared);
- this.path = requireNonNull(path);
+ super(declared, substatements);
this.flags = flags;
- this.substatements = maskList(substatements);
}
@Override
return flags;
}
- @Override
- public Immutable pathObject() {
- return path;
- }
-
- @Override
- public @NonNull QName argument() {
- return getQName();
- }
-
- @Override
- public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
- return unmaskList(substatements);
- }
-
@Override
public TypeDefinition<?> getTypeDefinition() {
final TypeDefinition<?> existing = (TypeDefinition<?>) TYPE_DEFINITION.getAcquire(this);
private @NonNull TypeDefinition<?> loadTypeDefinition() {
final TypeEffectiveStatement<?> type = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
- final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(type.getTypeDefinition(), getQName());
+ final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(type.getTypeDefinition(), argument());
for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
if (stmt instanceof DefaultEffectiveStatement) {
@Override
public QName argument() {
- return getQName();
+ return TypedefEffectiveStatementImpl.this.argument();
}
@Override
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public final class UndeclaredCaseEffectiveStatement
extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement> implements CaseEffectiveStatementMixin {
private final @Nullable CaseSchemaNode original;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public UndeclaredCaseEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final Immutable path, final int flags, final @Nullable CaseSchemaNode original) {
+ final QName argument, final int flags, final @Nullable CaseSchemaNode original) {
super(substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = original;
}
- public UndeclaredCaseEffectiveStatement(final UndeclaredCaseEffectiveStatement origEffective, final Immutable path,
+ public UndeclaredCaseEffectiveStatement(final UndeclaredCaseEffectiveStatement origEffective, final QName argument,
final int flags, final @Nullable CaseSchemaNode original) {
super(origEffective);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
this.original = original;
}
@Override
- public int flags() {
- return flags;
+ public QName argument() {
+ return argument;
}
@Override
- public Immutable pathObject() {
- return path;
+ public int flags() {
+ return flags;
}
@Override
@Override
public String toString() {
- return UndeclaredCaseEffectiveStatement.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
+ return UndeclaredCaseEffectiveStatement.class.getSimpleName() + "[" + "qname=" + argument + "]";
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
public final class UndeclaredInputEffectiveStatement
extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public UndeclaredInputEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final Immutable path, final int flags) {
+ final QName argument, final int flags) {
super(substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
- public UndeclaredInputEffectiveStatement(final UndeclaredInputEffectiveStatement original, final Immutable path,
+ public UndeclaredInputEffectiveStatement(final UndeclaredInputEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
public final class UndeclaredOutputEffectiveStatement
extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final int flags;
public UndeclaredOutputEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final Immutable path, final int flags) {
+ final QName argument, final int flags) {
super(substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
- public UndeclaredOutputEffectiveStatement(final UndeclaredOutputEffectiveStatement original, final Immutable path,
+ public UndeclaredOutputEffectiveStatement(final UndeclaredOutputEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.flags = flags;
}
@Override
- public Immutable pathObject() {
- return path;
+ public QName argument() {
+ return argument;
}
@Override
}
@Override
- public final D getDeclared() {
+ public final @NonNull D getDeclared() {
return declared;
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
*
- * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
- public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
- extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
+ public interface DataSchemaNodeMixin<D extends DeclaredStatement<QName>>
+ extends DataSchemaNode, CopyableMixin<QName, D>, SchemaNodeMixin<D>, WhenConditionMixin<QName, D> {
@Override
default Optional<Boolean> effectiveConfig() {
final int fl = flags() & FlagsBuilder.MASK_CONFIG;
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
*
- * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
- public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
- extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
- // FIXME: ditch all this complexity once we do not require SchemaPath
+ public interface SchemaNodeMixin<D extends DeclaredStatement<QName>>
+ extends DocumentedNodeMixin.WithStatus<QName, D>, SchemaNode {
@Override
default QName getQName() {
- return SchemaNodeDefaults.extractQName(pathObject());
+ return argument();
}
-
- @Override
- @Deprecated
- default SchemaPath getPath() {
- return SchemaNodeDefaults.extractPath(this, pathObject());
- }
-
- @NonNull Immutable pathObject();
}
/**
* @param <D> Class representing declared version of this statement.
*/
public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
- extends SchemaNodeMixin<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
-
+ extends DocumentedNodeMixin.WithStatus<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
@Override
default String getNodeParameter() {
return Strings.nullToEmpty(getDeclared().rawArgument());
public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
extends ContainerLike, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
- SchemaNodeMixin<QName, D>, CopyableMixin<QName, D> {
- @Override
- default @NonNull QName argument() {
- return getQName();
- }
-
+ SchemaNodeMixin<D>, CopyableMixin<QName, D> {
@Override
default Optional<ActionDefinition> findAction(final QName qname) {
return Optional.empty();
* @param <D> Class representing declared version of this statement.
*/
public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
- extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
+ extends DerivableSchemaNode, DataSchemaNodeMixin<D>, DocumentedNodeMixin.WithStatus<QName, D>,
MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
@Override
- default @NonNull QName argument() {
- return getQName();
+ default QName getQName() {
+ return argument();
}
}
* @param <D> Class representing declared version of this statement.
*/
public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
- extends SchemaNodeMixin<QName, D>, OperationDefinition {
- @Override
- default @NonNull QName argument() {
- return getQName();
- }
-
+ extends SchemaNodeMixin<D>, OperationDefinition {
@Override
default Collection<? extends @NonNull TypeDefinition<?>> getTypeDefinitions() {
return filterTypeDefinitions(this);
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueEffectiveStatement;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class OpenConfigHashedValueEffectiveStatementImpl
extends UnknownEffectiveStatementBase<Empty, OpenConfigHashedValueStatement>
implements OpenConfigHashedValueEffectiveStatement {
private final @NonNull StatementDefinition definition;
- private final @NonNull Immutable path;
OpenConfigHashedValueEffectiveStatementImpl(final Current<Empty, OpenConfigHashedValueStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
definition = stmt.publicDefinition();
- path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
- .createChild(stmt.publicDefinition().getStatementName()));
}
@Override
public QName getQName() {
- return SchemaNodeDefaults.extractQName(path);
- }
-
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.extractPath(this, path);
+ return definition.getStatementName();
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesEffectiveStatement;
import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesSchemaNode;
import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesStatement;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class GetFilterElementAttributesEffectiveStatementImpl
extends UnknownEffectiveStatementBase<Empty, GetFilterElementAttributesStatement>
implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode {
- private final @NonNull Immutable path;
+ private final @NonNull QName qname;
GetFilterElementAttributesEffectiveStatementImpl(final Current<Empty, GetFilterElementAttributesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
- .createChild(stmt.publicDefinition().getStatementName()));
+ qname = stmt.publicDefinition().getStatementName();
}
@Override
public QName getQName() {
- return SchemaNodeDefaults.extractQName(path);
- }
-
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.extractPath(this, path);
+ return qname;
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllEffectiveStatement;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllSchemaNode;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllStatement;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class DefaultDenyAllEffectiveStatementImpl extends UnknownEffectiveStatementBase<Empty, DefaultDenyAllStatement>
implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode {
- private final @NonNull Immutable path;
+ private final @NonNull QName qname;
DefaultDenyAllEffectiveStatementImpl(final Current<Empty, DefaultDenyAllStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
- .createChild(stmt.publicDefinition().getStatementName()));
+ qname = stmt.publicDefinition().getStatementName();
}
@Override
public QName getQName() {
- return SchemaNodeDefaults.extractQName(path);
- }
-
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.extractPath(this, path);
+ return qname;
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteEffectiveStatement;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteSchemaNode;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteStatement;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class DefaultDenyWriteEffectiveStatementImpl
extends UnknownEffectiveStatementBase<Empty, DefaultDenyWriteStatement>
implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode {
- private final @NonNull Immutable path;
+ private final @NonNull QName qname;
DefaultDenyWriteEffectiveStatementImpl(final Current<Empty, DefaultDenyWriteStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
- .createChild(stmt.publicDefinition().getStatementName()));
+ qname = stmt.publicDefinition().getStatementName();
}
@Override
public QName getQName() {
- return SchemaNodeDefaults.extractQName(path);
- }
-
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.extractPath(this, path);
+ return qname;
}
@Override
import org.opendaylight.yangtools.rfc6643.model.api.AliasSchemaNode;
import org.opendaylight.yangtools.rfc6643.model.api.AliasStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class AliasEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, AliasStatement>
implements AliasEffectiveStatement, AliasSchemaNode {
- private final SchemaPath path;
-
AliasEffectiveStatementImpl(final Current<String, AliasStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public AliasEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final AliasEffectiveStatementImpl other = (AliasEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
import org.opendaylight.yangtools.rfc6643.model.api.DefValSchemaNode;
import org.opendaylight.yangtools.rfc6643.model.api.DefValStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class DefValEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, DefValStatement>
implements DefValEffectiveStatement, DefValSchemaNode {
- private final SchemaPath path;
-
DefValEffectiveStatementImpl(final Current<String, DefValStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public DefValEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final DefValEffectiveStatementImpl other = (DefValEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintSchemaNode;
import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class DisplayHintEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, DisplayHintStatement>
implements DisplayHintEffectiveStatement, DisplayHintSchemaNode {
- private final SchemaPath path;
-
DisplayHintEffectiveStatementImpl(final Current<String, DisplayHintStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public DisplayHintEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final DisplayHintEffectiveStatementImpl other = (DisplayHintEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
import org.opendaylight.yangtools.rfc6643.model.api.ImpliedSchemaNode;
import org.opendaylight.yangtools.rfc6643.model.api.ImpliedStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class ImpliedEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, ImpliedStatement>
implements ImpliedEffectiveStatement, ImpliedSchemaNode {
-
- private final SchemaPath path;
-
ImpliedEffectiveStatementImpl(final Current<String, ImpliedStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public ImpliedEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final ImpliedEffectiveStatementImpl other = (ImpliedEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessSchemaNode;
import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class MaxAccessEffectiveStatementImpl extends UnknownEffectiveStatementBase<MaxAccess, MaxAccessStatement>
implements MaxAccessEffectiveStatement, MaxAccessSchemaNode {
- private final SchemaPath path;
-
MaxAccessEffectiveStatementImpl(final Current<MaxAccess, MaxAccessStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public MaxAccessEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final MaxAccessEffectiveStatementImpl other = (MaxAccessEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
import org.opendaylight.yangtools.rfc6643.model.api.OidSchemaNode;
import org.opendaylight.yangtools.rfc6643.model.api.OidStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class OidEffectiveStatementImpl extends UnknownEffectiveStatementBase<ObjectIdentifier, OidStatement>
implements OidEffectiveStatement, OidSchemaNode {
-
- private final SchemaPath path;
-
OidEffectiveStatementImpl(final Current<ObjectIdentifier, OidStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public OidEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final OidEffectiveStatementImpl other = (OidEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
\ No newline at end of file
import org.opendaylight.yangtools.rfc6643.model.api.SubIdStatement;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class SubIdEffectiveStatementImpl extends UnknownEffectiveStatementBase<Uint32, SubIdStatement>
implements SubIdEffectiveStatement, SubIdSchemaNode {
-
- private final SchemaPath path;
-
SubIdEffectiveStatementImpl(final Current<Uint32, SubIdStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public SubIdEffectiveStatement asEffectiveStatement() {
return this;
@Override
public int hashCode() {
- return Objects.hash(path, getNodeType(), getNodeParameter());
+ return Objects.hash(getNodeType(), getNodeParameter());
}
@Override
}
final SubIdEffectiveStatementImpl other = (SubIdEffectiveStatementImpl) obj;
return Objects.equals(getNodeType(), other.getNodeType())
- && Objects.equals(getNodeParameter(), other.getNodeParameter()) && Objects.equals(path, other.path);
+ && Objects.equals(getNodeParameter(), other.getNodeParameter());
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationEffectiveStatement;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypes;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
final class AnnotationEffectiveStatementImpl extends UnknownEffectiveStatementBase<QName, AnnotationStatement>
implements AnnotationEffectiveStatement, AnnotationSchemaNode {
private final @NonNull TypeDefinition<?> type;
- private final @Nullable SchemaPath path;
AnnotationEffectiveStatementImpl(final Current<QName, AnnotationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
builder.setUnits(unitsStmt.argument());
}
type = builder.build();
-
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(qname));
}
@Override
return verifyNotNull(argument());
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public TypeDefinition<?> getType() {
return type;
import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.rfc8040.model.api.YangDataEffectiveStatement;
import org.opendaylight.yangtools.rfc8040.model.api.YangDataSchemaNode;
import org.opendaylight.yangtools.rfc8040.model.api.YangDataStatement;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
@Beta
final class YangDataEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, YangDataStatement>
implements YangDataEffectiveStatement, YangDataSchemaNode {
- private final @Nullable SchemaPath path;
private final @NonNull QName argumentQName;
private final @NonNull ContainerEffectiveStatement container;
super(stmt, substatements);
this.argumentQName = requireNonNull(qname);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(qname));
container = findFirstEffectiveSubstatement(ContainerEffectiveStatement.class).get();
// TODO: this is strong binding of two API contracts. Unfortunately ContainerEffectiveStatement design is
return argumentQName;
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public ContainerEffectiveStatement getContainer() {
return container;
public String toString() {
return MoreObjects.toStringHelper(this).omitNullValues()
.add("qname", argumentQName)
- .add("path", path)
.add("container", container).toString();
}
}
import static com.google.common.base.Verify.verifyNotNull;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointEffectiveStatement;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointSchemaNode;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class MountPointEffectiveStatementImpl extends UnknownEffectiveStatementBase<QName, MountPointStatement>
implements MountPointEffectiveStatement, MountPointSchemaNode {
- private final @Nullable SchemaPath path;
-
MountPointEffectiveStatementImpl(final Current<QName, MountPointStatement> stmt,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final @Nullable SchemaPath path) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- this.path = path;
}
@Override
return verifyNotNull(argument());
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public MountPointEffectiveStatement asEffectiveStatement() {
return this;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
copy.getArgument().equals(current.getArgument())
// Implied by UnknownSchemaNode
&& copy.history().isAugmenting() == current.history().isAugmenting()
- && copy.history().isAddedByUses() == current.history().isAddedByUses()
- && copy.equalParentPath(current)), config, VALIDATOR);
+ && copy.history().isAddedByUses() == current.history().isAddedByUses()), config, VALIDATOR);
}
// FIXME: these two methods are not quite right. RFC8528 states that:
@Override
protected MountPointEffectiveStatement createEffective(final Current<QName, MountPointStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new MountPointEffectiveStatementImpl(stmt, substatements, SchemaPathSupport.toOptionalPath(
- stmt.getEffectiveParent().getSchemaPath().createChild(stmt.getArgument())));
+ return new MountPointEffectiveStatementImpl(stmt, substatements);
}
}
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
* below methods exist in the same form in SubstatementContext. If any adjustment is made here, make sure it is
* properly updated there.
*/
- @Override
- @Deprecated
- public SchemaPath schemaPath() {
- return substatementGetSchemaPath();
- }
-
@Override
public A argument() {
return argument;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
// FIXME: move this out once we have JDK15+
private boolean boolFlag;
- // SchemaPath cache for use with SubstatementContext and InferredStatementContext. This hurts RootStatementContext
- // a bit in terms of size -- but those are only a few and SchemaPath is on its way out anyway.
- // FIXME: this should become 'QName'
- private SchemaPath schemaPath;
-
ReactorStmtCtx() {
// Empty on purpose
}
@Override
public final QName argumentAsTypeQName() {
- return interpretAsQName(getRawArgument());
+ // FIXME: This may yield illegal argument exceptions
+ return StmtContextUtils.qnameFromArgument(getOriginalCtx().orElse(this), getRawArgument());
}
@Override
public final QNameModule effectiveNamespace() {
- // FIXME: there has to be a better way to do this
- return getSchemaPath().getLastComponent().getModule();
- }
-
- //
- //
- // Common SchemaPath cache. All of this is bound to be removed once YANGTOOLS-1066 is done.
- //
- //
-
- // Exists only to support {SubstatementContext,InferredStatementContext}.schemaPath()
- @Deprecated
- final @Nullable SchemaPath substatementGetSchemaPath() {
- if (schemaPath == null) {
- schemaPath = createSchemaPath((StatementContextBase<?, ?, ?>) coerceParentContext());
- }
- return schemaPath;
- }
-
- // FIXME: 7.0.0: this method's logic needs to be moved to the respective StatementSupport classes
- @Deprecated
- private SchemaPath createSchemaPath(final StatementContextBase<?, ?, ?> parent) {
- final SchemaPath parentPath = parent.getSchemaPath();
if (StmtContextUtils.isUnknownStatement(this)) {
- return parentPath.createChild(publicDefinition().getStatementName());
+ return publicDefinition().getStatementName().getModule();
+ }
+ if (producesDeclared(UsesStatement.class)) {
+ return coerceParent().effectiveNamespace();
}
+
final Object argument = argument();
if (argument instanceof QName) {
- final QName qname = (QName) argument;
- if (producesDeclared(UsesStatement.class)) {
- return parentPath;
- }
-
- return parentPath.createChild(qname);
+ return ((QName) argument).getModule();
}
if (argument instanceof String) {
- return parentPath.createChild(interpretAsQName((String) argument));
+ // FIXME: This may yield illegal argument exceptions
+ return StmtContextUtils.qnameFromArgument(getOriginalCtx().orElse(this), (String) argument).getModule();
}
if (argument instanceof SchemaNodeIdentifier
&& (producesDeclared(AugmentStatement.class) || producesDeclared(RefineStatement.class)
|| producesDeclared(DeviationStatement.class))) {
-
- return parentPath.createChild(((SchemaNodeIdentifier) argument).getNodeIdentifiers());
+ return ((SchemaNodeIdentifier) argument).lastNodeIdentifier().getModule();
}
- // FIXME: this does not look right, investigate more?
- return parentPath;
+ return coerceParent().effectiveNamespace();
}
- private @NonNull QName interpretAsQName(final String argument) {
- // FIXME: This may yield illegal argument exceptions
- return StmtContextUtils.qnameFromArgument(getOriginalCtx().orElse(this), argument);
+ private ReactorStmtCtx<?, ?, ?> coerceParent() {
+ return (ReactorStmtCtx<?, ?, ?>) coerceParentContext();
}
//
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
* below methods exist in the same form in InferredStatementContext/SubstatementContext. If any adjustment is made
* here, make sure it is properly updated there.
*/
- @Override
- @Deprecated
- public SchemaPath schemaPath() {
- return substatementGetSchemaPath();
- }
-
@Override
public StatementContextBase<?, ?, ?> getParentContext() {
return parent;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
return argument;
}
- @Override
- @Deprecated
- public SchemaPath schemaPath() {
- return SchemaPath.ROOT;
- }
-
@Override
public EffectiveConfig effectiveConfig() {
return EffectiveConfig.UNDETERMINED;
import static java.util.Objects.requireNonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
* below methods exist in the same form in InferredStatementContext. If any adjustment is made here, make sure it is
* properly updated there.
*/
- @Override
- @Deprecated
- public SchemaPath schemaPath() {
- return substatementGetSchemaPath();
- }
-
@Override
public A argument() {
return argument;
package org.opendaylight.yangtools.yang.parser.openconfig.stmt;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionEffectiveStatement;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class OpenConfigVersionEffectiveStatementImpl
extends UnknownEffectiveStatementBase<SemVer, OpenConfigVersionStatement>
implements OpenConfigVersionEffectiveStatement {
-
- private final @Nullable SchemaPath path;
-
OpenConfigVersionEffectiveStatementImpl(final Current<SemVer, OpenConfigVersionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public OpenConfigVersionEffectiveStatement asEffectiveStatement() {
return this;
@Override
protected ExtensionEffectiveStatement createEffective(final Current<QName, ExtensionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return EffectiveStatements.createExtension(stmt.declared(), substatements, stmt.optionalPath());
+ return EffectiveStatements.createExtension(stmt.declared(), substatements);
}
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
abstract class AbstractLeafListEffectiveStatement
extends AbstractDeclaredEffectiveStatement.Default<QName, LeafListStatement>
implements LeafListEffectiveStatement, LeafListSchemaNode, DerivableSchemaNode,
- UserOrderedMixin<QName, LeafListStatement>, DataSchemaNodeMixin<QName, LeafListStatement>,
+ UserOrderedMixin<QName, LeafListStatement>, DataSchemaNodeMixin<LeafListStatement>,
MustConstraintMixin<QName, LeafListStatement> {
private final @NonNull Object substatements;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final @NonNull TypeDefinition<?> type;
private final int flags;
- AbstractLeafListEffectiveStatement(final LeafListStatement declared, final Immutable path, final int flags,
+ AbstractLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.substatements = maskList(substatements);
this.flags = flags;
// TODO: lazy instantiation?
this.type = buildType();
}
- AbstractLeafListEffectiveStatement(final AbstractLeafListEffectiveStatement original, final Immutable path,
+ AbstractLeafListEffectiveStatement(final AbstractLeafListEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.substatements = original.substatements;
this.flags = flags;
// TODO: lazy instantiation?
@Override
public final QName argument() {
- return getQName();
- }
-
- @Override
- public final Immutable pathObject() {
- return path;
+ return argument;
}
@Override
@Override
public final String toString() {
- return getClass().getSimpleName() + "[" + getQName() + "]";
+ return getClass().getSimpleName() + "[" + argument + "]";
}
private TypeDefinition<?> buildType() {
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
+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;
private final @Nullable LeafListSchemaNode original;
private final @Nullable ElementCountConstraint elementCountConstraint;
- AbstractNonEmptyLeafListEffectiveStatement(final LeafListStatement declared, final Immutable path, final int flags,
+ AbstractNonEmptyLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final LeafListSchemaNode original, final ElementCountConstraint elementCountConstraint) {
- super(declared, path, flags, substatements);
+ super(declared, argument, flags, substatements);
this.original = original;
this.elementCountConstraint = elementCountConstraint;
}
AbstractNonEmptyLeafListEffectiveStatement(final AbstractNonEmptyLeafListEffectiveStatement originalEffecive,
- final LeafListSchemaNode original, final Immutable path, final int flags) {
- super(originalEffecive, path, flags);
+ final LeafListSchemaNode original, final QName argument, final int flags) {
+ super(originalEffecive, argument, flags);
this.elementCountConstraint = originalEffecive.elementCountConstraint;
this.original = original;
}
AbstractNonEmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final Immutable path, final int flags) {
- super(originalEffective, path, flags);
+ final LeafListSchemaNode original, final QName argument, final int flags) {
+ super(originalEffective, argument, flags);
this.elementCountConstraint = null;
this.original = original;
}
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
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.LeafListStatement;
final class EmptyLeafListEffectiveStatement extends AbstractLeafListEffectiveStatement {
- EmptyLeafListEffectiveStatement(final LeafListStatement declared, final Immutable path, final int flags,
+ EmptyLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, path, flags, substatements);
+ super(declared, argument, flags, substatements);
}
- EmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement original, final Immutable path,
+ EmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement original, final QName argument,
final int flags) {
- super(original, path, flags);
+ super(original, argument, flags);
}
@Override
final int flags = computeFlags(stmt, original.effectiveSubstatements());
if (original instanceof RegularLeafListEffectiveStatement) {
return new RegularLeafListEffectiveStatement((RegularLeafListEffectiveStatement) original,
- stmt.original(LeafListSchemaNode.class), stmt.effectivePath(), flags);
+ stmt.original(LeafListSchemaNode.class), stmt.getArgument(), flags);
} else if (original instanceof SlimLeafListEffectiveStatement) {
return new SlimLeafListEffectiveStatement((SlimLeafListEffectiveStatement) original,
- stmt.original(LeafListSchemaNode.class), stmt.effectivePath(), flags);
+ stmt.original(LeafListSchemaNode.class), stmt.getArgument(), flags);
} else if (original instanceof EmptyLeafListEffectiveStatement) {
// Promote to slim
return new SlimLeafListEffectiveStatement((EmptyLeafListEffectiveStatement) original,
- stmt.original(LeafListSchemaNode.class), stmt.effectivePath(), flags);
+ stmt.original(LeafListSchemaNode.class), stmt.getArgument(), flags);
} else {
// Safe fallback
return super.copyEffective(stmt, original);
final LeafListStatement declared = stmt.declared();
if (defaultValues.isEmpty()) {
return original == null && !elementCountConstraint.isPresent()
- ? new EmptyLeafListEffectiveStatement(declared, stmt.effectivePath(), flags, substatements)
- : new SlimLeafListEffectiveStatement(declared, stmt.effectivePath(), flags, substatements, original,
+ ? new EmptyLeafListEffectiveStatement(declared, stmt.getArgument(), flags, substatements)
+ : new SlimLeafListEffectiveStatement(declared, stmt.getArgument(), flags, substatements, original,
elementCountConstraint.orElse(null));
}
- return new RegularLeafListEffectiveStatement(declared, stmt.effectivePath(), flags, substatements, original,
+ return new RegularLeafListEffectiveStatement(declared, stmt.getArgument(), flags, substatements, original,
defaultValues, elementCountConstraint.orElse(null));
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
+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;
final class RegularLeafListEffectiveStatement extends AbstractNonEmptyLeafListEffectiveStatement {
private final @NonNull ImmutableSet<String> defaults;
- RegularLeafListEffectiveStatement(final LeafListStatement declared, final Immutable path, final int flags,
+ 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, path, flags, substatements, original, elementCountConstraint);
+ super(declared, argument, flags, substatements, original, elementCountConstraint);
this.defaults = requireNonNull(defaults);
}
RegularLeafListEffectiveStatement(final RegularLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final Immutable path, final int flags) {
- super(originalEffective, original, path, flags);
+ final LeafListSchemaNode original, final QName argument, final int flags) {
+ super(originalEffective, original, argument, flags);
this.defaults = originalEffective.defaults;
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import org.opendaylight.yangtools.concepts.Immutable;
+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;
final class SlimLeafListEffectiveStatement extends AbstractNonEmptyLeafListEffectiveStatement {
- SlimLeafListEffectiveStatement(final LeafListStatement declared, final Immutable path, final int flags,
+ SlimLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final LeafListSchemaNode original, final ElementCountConstraint elementCountConstraint) {
- super(declared, path, flags, substatements, original, elementCountConstraint);
+ super(declared, argument, flags, substatements, original, elementCountConstraint);
}
SlimLeafListEffectiveStatement(final SlimLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final Immutable path, final int flags) {
- super(originalEffective, original, path, flags);
+ final LeafListSchemaNode original, final QName argument, final int flags) {
+ super(originalEffective, original, argument, flags);
}
SlimLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final Immutable path, final int flags) {
- super(originalEffective, original, path, flags);
+ final LeafListSchemaNode original, final QName argument, final int flags) {
+ super(originalEffective, original, argument, flags);
}
@Override
import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
implements ListEffectiveStatement, ListSchemaNode, DerivableSchemaNode,
ActionNodeContainerCompat<QName, ListStatement, ListEffectiveStatement>,
NotificationNodeContainerCompat<QName, ListStatement, ListEffectiveStatement>,
- DataSchemaNodeMixin<QName, ListStatement>, UserOrderedMixin<QName, ListStatement>,
+ DataSchemaNodeMixin<ListStatement>, UserOrderedMixin<QName, ListStatement>,
DataNodeContainerMixin<QName, ListStatement>, WhenConditionMixin<QName, ListStatement>,
AugmentationTargetMixin<QName, ListStatement>, NotificationNodeContainerMixin<QName, ListStatement>,
ActionNodeContainerMixin<QName, ListStatement>, MustConstraintMixin<QName, ListStatement> {
private final int flags;
private final @NonNull Object substatements;
- private final @NonNull Immutable path;
+ private final @NonNull QName argument;
private final @NonNull Object keyDefinition;
- AbstractListEffectiveStatement(final ListStatement declared, final Immutable path, final int flags,
+ AbstractListEffectiveStatement(final ListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.substatements = maskList(substatements);
this.keyDefinition = maskList(keyDefinition);
this.flags = flags;
}
- AbstractListEffectiveStatement(final AbstractListEffectiveStatement original, final Immutable path,
+ AbstractListEffectiveStatement(final AbstractListEffectiveStatement original, final QName argument,
final int flags) {
super(original);
- this.path = requireNonNull(path);
+ this.argument = requireNonNull(argument);
this.substatements = original.substatements;
this.keyDefinition = original.keyDefinition;
this.flags = flags;
return unmaskList(substatements);
}
- @Override
- public final int flags() {
- return flags;
- }
-
@Override
public final QName argument() {
- return getQName();
+ return argument;
}
@Override
- public final Immutable pathObject() {
- return path;
+ public final int flags() {
+ return flags;
}
@Override
import com.google.common.collect.ImmutableList;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
final class EmptyListEffectiveStatement extends AbstractListEffectiveStatement {
- EmptyListEffectiveStatement(final ListStatement declared, final Immutable path, final int flags,
+ EmptyListEffectiveStatement(final ListStatement declared, final QName argument, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition) {
- super(declared, path, flags, substatements, keyDefinition);
+ super(declared, argument, flags, substatements, keyDefinition);
}
- EmptyListEffectiveStatement(final EmptyListEffectiveStatement original, final Immutable path, final int flags) {
- super(original, path, flags);
+ EmptyListEffectiveStatement(final EmptyListEffectiveStatement original, final QName argument, final int flags) {
+ super(original, argument, flags);
}
@Override
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.Ordering;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
final int flags = computeFlags(stmt, original.effectiveSubstatements());
if (original instanceof RegularListEffectiveStatement) {
return new RegularListEffectiveStatement((RegularListEffectiveStatement) original,
- stmt.original(ListSchemaNode.class), stmt.effectivePath(), flags);
+ stmt.original(ListSchemaNode.class), stmt.getArgument(), flags);
} else if (original instanceof EmptyListEffectiveStatement) {
return new RegularListEffectiveStatement((EmptyListEffectiveStatement) original,
- stmt.original(ListSchemaNode.class), stmt.effectivePath(), flags);
+ stmt.original(ListSchemaNode.class), stmt.getArgument(), flags);
} else {
// Safe fallback
return super.copyEffective(stmt, original);
final Optional<ElementCountConstraint> elementCountConstraint =
EffectiveStmtUtils.createElementCountConstraint(substatements);
- final Immutable path = stmt.effectivePath();
+ final QName qname = stmt.getArgument();
final ListSchemaNode original = stmt.original(ListSchemaNode.class);
try {
return original == null && !elementCountConstraint.isPresent()
- ? new EmptyListEffectiveStatement(stmt.declared(), path, flags, substatements, keyDefinition)
- : new RegularListEffectiveStatement(stmt.declared(), path, flags, substatements, keyDefinition,
+ ? new EmptyListEffectiveStatement(stmt.declared(), qname, flags, substatements, keyDefinition)
+ : new RegularListEffectiveStatement(stmt.declared(), qname, flags, substatements, keyDefinition,
elementCountConstraint.orElse(null), original);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
import com.google.common.collect.ImmutableList;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
private final ElementCountConstraint elementCountConstraint;
private final ListSchemaNode original;
- RegularListEffectiveStatement(final ListStatement declared, final Immutable path, final int flags,
+ 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) {
- super(declared, path, flags, substatements, keyDefinition);
+ super(declared, argument, flags, substatements, keyDefinition);
this.elementCountConstraint = elementCountConstraint;
this.original = original;
}
RegularListEffectiveStatement(final RegularListEffectiveStatement originalEffective, final ListSchemaNode original,
- final Immutable path, final int flags) {
- super(originalEffective, path, flags);
+ final QName argument, final int flags) {
+ super(originalEffective, argument, flags);
this.elementCountConstraint = originalEffective.elementCountConstraint;
this.original = original;
}
RegularListEffectiveStatement(final EmptyListEffectiveStatement originalEffective, final ListSchemaNode original,
- final Immutable path, final int flags) {
- super(originalEffective, path, flags);
+ final QName argument, final int flags) {
+ super(originalEffective, argument, flags);
this.elementCountConstraint = null;
this.original = original;
}
verify(!substatements.isEmpty(), "Missing implicit input/output statements at %s", ref);
try {
- return EffectiveStatements.createAction(stmt.declared(), stmt.effectivePath(),
+ return EffectiveStatements.createAction(stmt.declared(), stmt.getArgument(),
EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements), substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
@Override
public ActionEffectiveStatement copyEffective(final Current<QName, ActionStatement> stmt,
final ActionEffectiveStatement original) {
- return EffectiveStatements.copyAction(original, stmt.effectivePath(),
+ return EffectiveStatements.copyAction(original, stmt.getArgument(),
EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()));
}
}
@Override
protected AnydataEffectiveStatement createEffective(final Current<QName, AnydataStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return EffectiveStatements.createAnydata(stmt.declared(), stmt.effectivePath(),
+ return EffectiveStatements.createAnydata(stmt.declared(), stmt.getArgument(),
createFlags(stmt, substatements), substatements, stmt.original(AnydataSchemaNode.class));
}
@Override
public AnydataEffectiveStatement copyEffective(final Current<QName, AnydataStatement> stmt,
final AnydataEffectiveStatement original) {
- return EffectiveStatements.copyAnydata(original, stmt.effectivePath(),
+ return EffectiveStatements.copyAnydata(original, stmt.getArgument(),
createFlags(stmt, original.effectiveSubstatements()), stmt.original(AnydataSchemaNode.class));
}
@Override
protected AnyxmlEffectiveStatement createEffective(final Current<QName, AnyxmlStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return EffectiveStatements.createAnyxml(stmt.declared(), stmt.effectivePath(), createFlags(stmt, substatements),
+ return EffectiveStatements.createAnyxml(stmt.declared(), stmt.getArgument(), createFlags(stmt, substatements),
substatements, stmt.original(AnyxmlSchemaNode.class));
}
@Override
public AnyxmlEffectiveStatement copyEffective(final Current<QName, AnyxmlStatement> stmt,
final AnyxmlEffectiveStatement original) {
- return EffectiveStatements.copyAnyxml(original, stmt.effectivePath(),
+ return EffectiveStatements.copyAnyxml(original, stmt.getArgument(),
createFlags(stmt, original.effectiveSubstatements()), stmt.original(AnyxmlSchemaNode.class));
}
@Override
protected CaseEffectiveStatement copyDeclaredEffective(final Current<QName, CaseStatement> stmt,
final CaseEffectiveStatement original) {
- return EffectiveStatements.copyCase(original, stmt.effectivePath(),
+ return EffectiveStatements.copyCase(original, stmt.getArgument(),
computeFlags(stmt, original.effectiveSubstatements()), stmt.original(CaseSchemaNode.class));
}
@Override
protected CaseEffectiveStatement copyUndeclaredEffective(final Current<QName, CaseStatement> stmt,
final CaseEffectiveStatement original) {
- return EffectiveStatements.copyCase(original, stmt.effectivePath(),
+ return EffectiveStatements.copyCase(original, stmt.getArgument(),
computeFlags(stmt, original.effectiveSubstatements()), stmt.original(CaseSchemaNode.class));
}
protected CaseEffectiveStatement createDeclaredEffective(final Current<QName, CaseStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createCase(stmt.declared(), stmt.effectivePath(),
+ return EffectiveStatements.createCase(stmt.declared(), stmt.getArgument(),
computeFlags(stmt, substatements), substatements, stmt.original(CaseSchemaNode.class));
} 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.effectivePath(), computeFlags(stmt, substatements),
+ return EffectiveStatements.createCase(stmt.getArgument(), computeFlags(stmt, substatements),
substatements, stmt.original(CaseSchemaNode.class));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
@Override
public ChoiceEffectiveStatement copyEffective(final Current<QName, ChoiceStatement> stmt,
final ChoiceEffectiveStatement original) {
- return EffectiveStatements.copyChoice(original, stmt.effectivePath(),
+ return EffectiveStatements.copyChoice(original, stmt.getArgument(),
computeFlags(stmt, original.effectiveSubstatements()), stmt.original(ChoiceSchemaNode.class));
}
}
try {
- return EffectiveStatements.createChoice(stmt.declared(), stmt.effectivePath(),
+ return EffectiveStatements.createChoice(stmt.declared(), stmt.getArgument(),
computeFlags(stmt, substatements), substatements, defaultCase, stmt.original(ChoiceSchemaNode.class));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
EffectiveStmtUtils.checkUniqueUses(stmt, substatements);
try {
- return EffectiveStatements.createContainer(stmt.declared(), stmt.effectivePath(),
+ return EffectiveStatements.createContainer(stmt.declared(), stmt.getArgument(),
createFlags(stmt, substatements), substatements, stmt.original(ContainerSchemaNode.class));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
@Override
public ContainerEffectiveStatement copyEffective(final Current<QName, ContainerStatement> stmt,
final ContainerEffectiveStatement original) {
- return EffectiveStatements.copyContainer(original, stmt.effectivePath(),
+ return EffectiveStatements.copyContainer(original, stmt.getArgument(),
createFlags(stmt, original.effectiveSubstatements()), stmt.original(ContainerSchemaNode.class));
}
@Override
protected FeatureEffectiveStatement createEffective(final Current<QName, FeatureStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return EffectiveStatements.createFeature(stmt.declared(), stmt.effectivePath(), computeFlags(substatements),
- substatements);
+ return EffectiveStatements.createFeature(stmt.declared(), computeFlags(substatements), substatements);
}
private static int computeFlags(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(YangStmtMapping.GROUPING, StatementPolicy.copyDeclared(
(copy, current, substatements) ->
copy.history().isAddedByUses() == current.history().isAddedByUses()
- && copy.getArgument().equals(current.getArgument())
- && copy.equalParentPath(current)), config, validator);
+ && copy.getArgument().equals(current.getArgument())), config, validator);
}
public static @NonNull GroupingStatementSupport rfc6020Instance(final YangParserConfiguration config) {
protected GroupingEffectiveStatement createEffective(final Current<QName, GroupingStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createGrouping(stmt.declared(), substatements, stmt.effectivePath(),
+ return EffectiveStatements.createGrouping(stmt.declared(), substatements, stmt.getArgument(),
EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
protected IdentityEffectiveStatement createEffective(final Current<QName, IdentityStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
if (substatements.isEmpty()) {
- return EffectiveStatements.createIdentity(stmt.declared(), stmt.effectivePath());
+ return EffectiveStatements.createIdentity(stmt.declared());
}
final List<IdentitySchemaNode> identities = new ArrayList<>();
}
}
- return EffectiveStatements.createIdentity(stmt.declared(), stmt.effectivePath(), new FlagsBuilder()
+ return EffectiveStatements.createIdentity(stmt.declared(), new FlagsBuilder()
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags(), substatements, ImmutableSet.copyOf(identities));
}
@Override
InputEffectiveStatement copyDeclaredEffective(final int flags, final Current<QName, InputStatement> stmt,
final InputEffectiveStatement original) {
- return EffectiveStatements.copyInput(original, stmt.effectivePath(), flags);
+ return EffectiveStatements.copyInput(original, stmt.getArgument(), flags);
}
@Override
InputEffectiveStatement copyUndeclaredEffective(final int flags, final Current<QName, InputStatement> stmt,
final InputEffectiveStatement original) {
- return EffectiveStatements.copyInput(original, stmt.effectivePath(), flags);
+ return EffectiveStatements.copyInput(original, stmt.getArgument(), flags);
}
@Override
InputEffectiveStatement createDeclaredEffective(final int flags, final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createInput(stmt.declared(), stmt.effectivePath(), flags, substatements);
+ return EffectiveStatements.createInput(stmt.declared(), stmt.getArgument(), flags, substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
InputEffectiveStatement createUndeclaredEffective(final int flags, final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createInput(stmt.effectivePath(), flags, substatements);
+ return EffectiveStatements.createInput(stmt.getArgument(), flags, substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
@Override
public LeafEffectiveStatement copyEffective(final Current<QName, LeafStatement> stmt,
final LeafEffectiveStatement original) {
- return EffectiveStatements.copyLeaf(original, stmt.effectivePath(),
+ return EffectiveStatements.copyLeaf(original, stmt.getArgument(),
computeFlags(stmt, original.effectiveSubstatements()), stmt.original(LeafSchemaNode.class));
}
EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeStmt, dflt), stmt,
"Leaf '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- return EffectiveStatements.createLeaf(stmt.declared(), stmt.effectivePath(), computeFlags(stmt, substatements),
+ return EffectiveStatements.createLeaf(stmt.declared(), stmt.getArgument(), computeFlags(stmt, substatements),
substatements, stmt.original(LeafSchemaNode.class));
}
@Override
OutputEffectiveStatement copyDeclaredEffective(final int flags, final Current<QName, OutputStatement> stmt,
final OutputEffectiveStatement original) {
- return EffectiveStatements.copyOutput(original, stmt.effectivePath(), flags);
+ return EffectiveStatements.copyOutput(original, stmt.getArgument(), flags);
}
@Override
OutputEffectiveStatement copyUndeclaredEffective(final int flags, final Current<QName, OutputStatement> stmt,
final OutputEffectiveStatement original) {
- return EffectiveStatements.copyOutput(original, stmt.effectivePath(), flags);
+ return EffectiveStatements.copyOutput(original, stmt.getArgument(), flags);
}
@Override
OutputEffectiveStatement createDeclaredEffective(final int flags, final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createOutput(stmt.declared(), stmt.effectivePath(), flags, substatements);
+ return EffectiveStatements.createOutput(stmt.declared(), stmt.getArgument(), flags, substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
OutputEffectiveStatement createUndeclaredEffective(final int flags, final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createOutput(stmt.effectivePath(), flags, substatements);
+ return EffectiveStatements.createOutput(stmt.getArgument(), flags, substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
checkState(!substatements.isEmpty(), "Missing implicit input/output statements at %s", stmt.sourceReference());
try {
- return EffectiveStatements.createRpc(stmt.declared(), substatements, stmt.effectivePath(),
+ return EffectiveStatements.createRpc(stmt.declared(), substatements, stmt.getArgument(),
computeFlags(substatements));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeEffectiveStmt, dflt), stmt,
"Typedef '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- return EffectiveStatements.createTypedef(declared, stmt.effectivePath(), computeFlags(substatements),
- substatements);
+ return EffectiveStatements.createTypedef(declared, computeFlags(substatements), substatements);
}
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
protected final NotificationEffectiveStatement createEffective(final Current<QName, NotificationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return EffectiveStatements.createNotification(stmt.declared(), stmt.effectivePath(),
+ return EffectiveStatements.createNotification(stmt.declared(), stmt.getArgument(),
EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements), substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
// FIXME: propagate original?
public final NotificationEffectiveStatement copyEffective(final Current<QName, NotificationStatement> stmt,
final NotificationEffectiveStatement original) {
- return EffectiveStatements.copyNotification(original, stmt.effectivePath(),
+ return EffectiveStatements.copyNotification(original, stmt.getArgument(),
EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()));
}
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
-import java.util.ArrayList;
import java.util.Collection;
-import java.util.List;
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.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.api.type.TypeDefinitions;
public void testAugmentParsing() throws Exception {
final SchemaContext context = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-augment")
.toURI());
- final List<QName> qnames = new ArrayList<>();
- qnames.add(Q0);
- qnames.add(Q1);
- qnames.add(Q2);
// foo.yang
final Module module1 = TestUtils.findModule(context, "foo").get();
final AugmentationSchemaNode augment = augmentations.iterator().next();
assertNotNull(augment);
- assertEquals(Absolute.of(qnames), augment.getTargetPath());
+ assertEquals(Absolute.of(Q0, Q1, Q2), augment.getTargetPath());
final Collection<? extends DataSchemaNode> augmentChildren = augment.getChildNodes();
assertEquals(4, augmentChildren.size());
assertNotNull(odl);
// leaf ds0ChannelNumber
- QName qname = QName.create(FOO, "ds0ChannelNumber");
- qnames.add(qname);
- assertEquals(qname, ds0ChannelNumber.getQName());
- SchemaPath expectedSchemaPath = SchemaPath.create(qnames, true);
- assertPathEquals(expectedSchemaPath, ds0ChannelNumber);
+ assertEquals(QName.create(FOO, "ds0ChannelNumber"), ds0ChannelNumber.getQName());
assertFalse(ds0ChannelNumber.isAugmenting());
// type of leaf ds0ChannelNumber
assertEquals(TypeDefinitions.STRING, ds0ChannelNumber.getType().getQName());
// leaf interface-id
- qname = QName.create(FOO, "interface-id");
- assertEquals(qname, interfaceId.getQName());
- qnames.set(3, qname);
- expectedSchemaPath = SchemaPath.create(qnames, true);
- assertPathEquals(expectedSchemaPath, interfaceId);
+ assertEquals(QName.create(FOO, "interface-id"), interfaceId.getQName());
assertFalse(interfaceId.isAugmenting());
// container schemas
- qname = QName.create(FOO, "schemas");
- assertEquals(qname, schemas.getQName());
- qnames.set(3, qname);
- expectedSchemaPath = SchemaPath.create(qnames, true);
- assertPathEquals(expectedSchemaPath, schemas);
+ assertEquals(QName.create(FOO, "schemas"), schemas.getQName());
assertFalse(schemas.isAugmenting());
// choice odl
- qname = QName.create(FOO, "odl");
- assertEquals(qname, odl.getQName());
- qnames.set(3, qname);
- expectedSchemaPath = SchemaPath.create(qnames, true);
- assertPathEquals(expectedSchemaPath, odl);
+ assertEquals(QName.create(FOO, "odl"), odl.getQName());
assertFalse(odl.isAugmenting());
// baz.yang
final ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName(QName.create(
module2.getQNameModule(), "ifEntry"));
- final List<QName> qnames = new ArrayList<>();
- qnames.add(Q0);
- qnames.add(Q1);
- qnames.add(Q2);
-
// baz.yang
// augment "/br:interfaces/br:ifEntry" {
final ContainerSchemaNode augmentHolder = (ContainerSchemaNode) ifEntry.getDataChildByName(QName.create(BAZ,
"augment-holder"));
TestUtils.checkIsAugmenting(augmentHolder, true);
assertEquals(Q2, augmentHolder.getQName());
- assertPathEquals(SchemaPath.create(qnames, true), augmentHolder);
// foo.yang
// augment "/br:interfaces/br:ifEntry/bz:augment-holder"
assertNotNull(odl);
// leaf ds0ChannelNumber
- QName qname = QName.create(FOO, "ds0ChannelNumber");
- assertEquals(qname, ds0ChannelNumber.getQName());
- qnames.add(qname);
- assertPathEquals(SchemaPath.create(qnames, true), ds0ChannelNumber);
+ assertEquals(QName.create(FOO, "ds0ChannelNumber"), ds0ChannelNumber.getQName());
// leaf interface-id
- qname = QName.create(FOO, "interface-id");
- assertEquals(qname, interfaceId.getQName());
- qnames.set(3, qname);
- assertPathEquals(SchemaPath.create(qnames, true), interfaceId);
+ assertEquals(QName.create(FOO, "interface-id"), interfaceId.getQName());
// container schemas
- qname = QName.create(FOO, "schemas");
- assertEquals(qname, schemas.getQName());
- qnames.set(3, qname);
- assertPathEquals(SchemaPath.create(qnames, true), schemas);
+ assertEquals(QName.create(FOO, "schemas"), schemas.getQName());
// choice odl
- qname = QName.create(FOO, "odl");
- assertEquals(qname, odl.getQName());
- qnames.set(3, qname);
- assertPathEquals(SchemaPath.create(qnames, true), odl);
+ assertEquals(QName.create(FOO, "odl"), odl.getQName());
}
@Test
assertNotNull(node2);
assertNotNull(node3);
- final List<QName> qnames = new ArrayList<>();
- qnames.add(Q0);
- qnames.add(Q1);
- qnames.add(Q2);
- qnames.add(QName.create(FOO, "odl"));
-
// case id
- QName qname = QName.create(FOO, "id");
- assertEquals(qname, id.getQName());
- qnames.add(qname);
- assertPathEquals(SchemaPath.create(qnames, true), id);
+ assertEquals(QName.create(FOO, "id"), id.getQName());
final Collection<? extends DataSchemaNode> idChildren = id.getChildNodes();
assertEquals(1, idChildren.size());
// case node1
- qname = QName.create(FOO, "node1");
- assertEquals(qname, node1.getQName());
- qnames.set(4, qname);
- assertPathEquals(SchemaPath.create(qnames, true), node1);
+ assertEquals(QName.create(FOO, "node1"), node1.getQName());
final Collection<? extends DataSchemaNode> node1Children = node1.getChildNodes();
assertTrue(node1Children.isEmpty());
// case node2
- qname = QName.create(FOO, "node2");
- assertEquals(qname, node2.getQName());
- qnames.set(4, qname);
- assertPathEquals(SchemaPath.create(qnames, true), node2);
+ assertEquals(QName.create(FOO, "node2"), node2.getQName());
final Collection<? extends DataSchemaNode> node2Children = node2.getChildNodes();
assertTrue(node2Children.isEmpty());
// case node3
- qname = QName.create(FOO, "node3");
- assertEquals(qname, node3.getQName());
- qnames.set(4, qname);
- assertPathEquals(SchemaPath.create(qnames, true), node3);
+ assertEquals(QName.create(FOO, "node3"), node3.getQName());
final Collection<? extends DataSchemaNode> node3Children = node3.getChildNodes();
assertEquals(1, node3Children.size());
// test cases
- qnames.clear();
- qnames.add(Q0);
- qnames.add(Q1);
- qnames.add(Q2);
- qnames.add(QName.create(FOO, "odl"));
-
// case id child
- qnames.add(QName.create(FOO, "id"));
- qnames.add(QName.create(FOO, "id"));
final LeafSchemaNode caseIdChild = (LeafSchemaNode) idChildren.iterator().next();
assertNotNull(caseIdChild);
- assertPathEquals(SchemaPath.create(qnames, true), caseIdChild);
+ assertEquals(QName.create(FOO, "id"), caseIdChild.getQName());
// case node3 child
- qnames.set(4, QName.create(FOO, "node3"));
- qnames.set(5, QName.create(FOO, "node3"));
final ContainerSchemaNode caseNode3Child = (ContainerSchemaNode) node3Children.iterator().next();
assertNotNull(caseNode3Child);
- assertPathEquals(SchemaPath.create(qnames, true), caseNode3Child);
+ assertEquals(QName.create(FOO, "node3"), caseNode3Child.getQName());
}
@Test
assertTrue(create.isAugmenting());
assertTrue(destroy.isAugmenting());
- final QName[] qnames = new QName[4];
- qnames[0] = submitQName;
- qnames[1] = inputQName;
- qnames[2] = argumentsQName;
-
// case attach
- qnames[3] = QName.create(NS_FOO, revision, "attach");
- assertEquals(qnames[3], attach.getQName());
- assertPathEquals(SchemaPath.create(true, qnames), attach);
+ assertEquals(QName.create(NS_FOO, revision, "attach"), attach.getQName());
final Collection<? extends DataSchemaNode> attachChildren = attach.getChildNodes();
assertEquals(1, attachChildren.size());
// case create
- qnames[3] = QName.create(NS_FOO, revision, "create");
- assertEquals(qnames[3], create.getQName());
- assertPathEquals(SchemaPath.create(true, qnames), create);
+ assertEquals(QName.create(NS_FOO, revision, "create"), create.getQName());
final Collection<? extends DataSchemaNode> createChildren = create.getChildNodes();
assertEquals(1, createChildren.size());
// case attach
- qnames[3] = QName.create(NS_FOO, revision, "destroy");
- assertEquals(qnames[3], destroy.getQName());
- assertPathEquals(SchemaPath.create(true, qnames), destroy);
+ assertEquals(QName.create(NS_FOO, revision, "destroy"), destroy.getQName());
final Collection<? extends DataSchemaNode> destroyChildren = destroy.getChildNodes();
assertEquals(1, destroyChildren.size());
}
final LeafSchemaNode id = (LeafSchemaNode) node.getDataChildByName(QName.create(test.getQNameModule(), "id"));
assertTrue(id.isAugmenting());
}
-
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.io.FileNotFoundException;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
ContainerSchemaNode grpSubSubCon2 = (ContainerSchemaNode) grpSubCon2.getDataChildByName(q6);
assertNotNull(grpSubSubCon2);
- assertPathEquals(SchemaPath.create(true, q1, q2, q3), subSubCon);
- assertPathEquals(SchemaPath.create(true, q4, q5, q6), subSubCon2);
- assertPathEquals(SchemaPath.create(true, q7, q5, q6), grpSubSubCon2);
+ assertEquals(q3, subSubCon.getQName());
+ assertEquals(q6, subSubCon2.getQName());
+ assertEquals(q6, grpSubSubCon2.getQName());
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.util.Collection;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.Submodule;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
public class EffectiveModuleTest {
-
- private static final StatementStreamSource ROOT_MODULE = sourceForResource(
- "/semantic-statement-parser/effective-module/root.yang");
- private static final StatementStreamSource IMPORTED_MODULE = sourceForResource(
- "/semantic-statement-parser/effective-module/imported.yang");
- private static final StatementStreamSource SUBMODULE = sourceForResource(
- "/semantic-statement-parser/effective-module/submod.yang");
-
private static final QNameModule ROOT_MODULE_QNAME = QNameModule.create(XMLNamespace.of("root-ns"));
-
private static final QName CONT = QName.create(ROOT_MODULE_QNAME, "cont");
private static final QName FEATURE1 = QName.create(ROOT_MODULE_QNAME, "feature1");
-
- private static final SchemaPath FEATURE1_SCHEMA_PATH = SchemaPath.create(true, FEATURE1);
-
private static final Revision REVISION = Revision.of("2000-01-01");
@Test
public void effectiveBuildTest() throws SourceException, ReactorException {
- SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
- .addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE)
- .buildEffective();
-
- assertNotNull(result);
-
- Module rootModule = result.findModules("root").iterator().next();
+ final Module rootModule = RFC7950Reactors.defaultReactor().newBuild()
+ .addSources(
+ sourceForResource("/semantic-statement-parser/effective-module/root.yang"),
+ sourceForResource("/semantic-statement-parser/effective-module/imported.yang"),
+ sourceForResource("/semantic-statement-parser/effective-module/submod.yang"))
+ .buildEffective()
+ .findModules("root").iterator().next();
assertNotNull(rootModule);
assertEquals("root-pref", rootModule.getPrefix());
final FeatureDefinition featureStmt = features.iterator().next();
assertNotNull(featureStmt);
assertEquals(FEATURE1, featureStmt.getQName());
- assertPathEquals(FEATURE1_SCHEMA_PATH, featureStmt);
assertEquals(Optional.of("feature1 description"), featureStmt.getDescription());
assertEquals(Optional.of("feature1 reference"), featureStmt.getReference());
assertEquals(Status.CURRENT, featureStmt.getStatus());
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
assertFalse(schemaContext.getDescription().isPresent());
assertFalse(schemaContext.getReference().isPresent());
assertEquals(SchemaContext.NAME, schemaContext.getQName());
- assertEquals(SchemaPath.ROOT, schemaContext.getPath());
assertEquals(Status.CURRENT, schemaContext.getStatus());
assertNotNull(schemaContext.getUses());
assertTrue(schemaContext.getUses().isEmpty());
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
-import java.util.Arrays;
+import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
-import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.Nullable;
-import org.junit.Before;
+import org.junit.BeforeClass;
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.Module;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
public class GroupingTest {
- private EffectiveModelContext ctx;
- private Module foo;
- private Module baz;
-
- @Before
- public void init() throws Exception {
- ctx = TestUtils.parseYangSources("/model");
- foo = TestUtils.findModule(ctx, "foo").get();
- baz = TestUtils.findModule(ctx, "baz").get();
- assertEquals(3, ctx.getModules().size());
+ private static EffectiveModelContext CTX;
+ private static Module FOO;
+ private static Module BAZ;
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ CTX = TestUtils.parseYangSources("/model");
+ assertEquals(3, CTX.getModules().size());
+
+ FOO = Iterables.getOnlyElement(CTX.findModules("foo"));
+ BAZ = Iterables.getOnlyElement(CTX.findModules("baz"));
}
@Test
public void testRefine() {
- final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
- foo.getQNameModule(), "peer"));
+ final ContainerSchemaNode peer = (ContainerSchemaNode) FOO.getDataChildByName(QName.create(
+ FOO.getQNameModule(), "peer"));
final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
- foo.getQNameModule(), "destination"));
+ FOO.getQNameModule(), "destination"));
final Collection<? extends UsesNode> usesNodes = destination.getUses();
assertEquals(1, usesNodes.size());
@Test
public void testGrouping() {
- final Collection<? extends GroupingDefinition> groupings = baz.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = BAZ.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
final Collection<? extends DataSchemaNode> children = grouping.getChildNodes();
// get grouping
- final Collection<? extends GroupingDefinition> groupings = baz.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = BAZ.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
// get node containing uses
- final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
- foo.getQNameModule(), "peer"));
+ final ContainerSchemaNode peer = (ContainerSchemaNode) FOO.getDataChildByName(QName.create(
+ FOO.getQNameModule(), "peer"));
final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
- foo.getQNameModule(), "destination"));
+ FOO.getQNameModule(), "destination"));
// check uses
final Collection<? extends UsesNode> uses = destination.getUses();
// check uses process
final AnyxmlSchemaNode data_u = (AnyxmlSchemaNode) destination.getDataChildByName(QName.create(
- foo.getQNameModule(), "data"));
+ FOO.getQNameModule(), "data"));
assertNotNull(data_u);
assertTrue(data_u.isAddedByUses());
final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "data"));
+ BAZ.getQNameModule(), "data"));
assertNotNull(data_g);
assertFalse(data_g.isAddedByUses());
assertFalse(data_u.equals(data_g));
assertEquals(data_g, extractOriginal(data_u));
final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
- foo.getQNameModule(), "how"));
+ FOO.getQNameModule(), "how"));
assertNotNull(how_u);
assertIsAddedByUses(how_u, true);
assertEquals(2, how_u.getCases().size());
final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "how"));
+ BAZ.getQNameModule(), "how"));
assertNotNull(how_g);
assertIsAddedByUses(how_g, false);
assertEquals(2, how_g.getCases().size());
assertEquals(how_g, extractOriginal(how_u));
final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
- foo.getQNameModule(), "address"));
+ FOO.getQNameModule(), "address"));
assertNotNull(address_u);
assertEquals(Optional.of("1.2.3.4"), address_u.getType().getDefaultValue());
assertEquals(Optional.of("IP address of target node"), address_u.getDescription());
assertFalse(address_u.isMandatory());
final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "address"));
+ BAZ.getQNameModule(), "address"));
assertNotNull(address_g);
assertFalse(address_g.isAddedByUses());
assertEquals(Optional.empty(), address_g.getType().getDefaultValue());
assertEquals(address_g, extractOriginal(address_u));
final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
- foo.getQNameModule(), "port"));
+ FOO.getQNameModule(), "port"));
assertNotNull(port_u);
assertIsAddedByUses(port_u, true);
final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "port"));
+ BAZ.getQNameModule(), "port"));
assertNotNull(port_g);
assertIsAddedByUses(port_g, false);
assertFalse(port_u.equals(port_g));
assertEquals(port_g, extractOriginal(port_u));
final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
- foo.getQNameModule(), "addresses"));
+ FOO.getQNameModule(), "addresses"));
assertNotNull(addresses_u);
assertIsAddedByUses(addresses_u, true);
final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "addresses"));
+ BAZ.getQNameModule(), "addresses"));
assertNotNull(addresses_g);
assertIsAddedByUses(addresses_g, false);
assertFalse(addresses_u.equals(addresses_g));
// suffix _g = defined in grouping
// get grouping
- final Collection<? extends GroupingDefinition> groupings = baz.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = BAZ.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
// check uses
- final Collection<? extends UsesNode> uses = foo.getUses();
+ final Collection<? extends UsesNode> uses = FOO.getUses();
assertEquals(1, uses.size());
// check uses process
- final AnyxmlSchemaNode data_u = (AnyxmlSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
+ final AnyxmlSchemaNode data_u = (AnyxmlSchemaNode) FOO.getDataChildByName(QName.create(FOO.getQNameModule(),
"data"));
assertNotNull(data_u);
assertTrue(data_u.isAddedByUses());
final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "data"));
+ BAZ.getQNameModule(), "data"));
assertNotNull(data_g);
assertFalse(data_g.isAddedByUses());
assertFalse(data_u.equals(data_g));
assertEquals(data_g, extractOriginal(data_u));
- final ChoiceSchemaNode how_u = (ChoiceSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
+ final ChoiceSchemaNode how_u = (ChoiceSchemaNode) FOO.getDataChildByName(QName.create(FOO.getQNameModule(),
"how"));
assertNotNull(how_u);
assertIsAddedByUses(how_u, true);
assertEquals(2, cases_u.size());
final CaseSchemaNode interval = how_u.findCaseNodes("interval").iterator().next();
assertFalse(interval.isAugmenting());
- final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(QName.create(foo.getQNameModule(),
+ final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(QName.create(FOO.getQNameModule(),
"name"));
assertTrue(name.isAugmenting());
final LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName(QName.create(
- foo.getQNameModule(), "interval"));
+ FOO.getQNameModule(), "interval"));
assertFalse(intervalLeaf.isAugmenting());
final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "how"));
+ BAZ.getQNameModule(), "how"));
assertNotNull(how_g);
assertIsAddedByUses(how_g, false);
assertFalse(how_u.equals(how_g));
assertEquals(how_g, extractOriginal(how_u));
- final LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
+ final LeafSchemaNode address_u = (LeafSchemaNode) FOO.getDataChildByName(QName.create(FOO.getQNameModule(),
"address"));
assertNotNull(address_u);
assertEquals(Optional.empty(), address_u.getType().getDefaultValue());
assertTrue(address_u.isAddedByUses());
final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "address"));
+ BAZ.getQNameModule(), "address"));
assertNotNull(address_g);
assertFalse(address_g.isAddedByUses());
assertEquals(Optional.empty(), address_g.getType().getDefaultValue());
assertFalse(address_u.equals(address_g));
assertEquals(address_g, extractOriginal(address_u));
- final ContainerSchemaNode port_u = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
- foo.getQNameModule(), "port"));
+ final ContainerSchemaNode port_u = (ContainerSchemaNode) FOO.getDataChildByName(QName.create(
+ FOO.getQNameModule(), "port"));
assertNotNull(port_u);
assertIsAddedByUses(port_u, true);
final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "port"));
+ BAZ.getQNameModule(), "port"));
assertNotNull(port_g);
assertIsAddedByUses(port_g, false);
assertFalse(port_u.equals(port_g));
assertEquals(port_g, extractOriginal(port_u));
- final ListSchemaNode addresses_u = (ListSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
+ final ListSchemaNode addresses_u = (ListSchemaNode) FOO.getDataChildByName(QName.create(FOO.getQNameModule(),
"addresses"));
assertNotNull(addresses_u);
assertIsAddedByUses(addresses_u, true);
final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
- baz.getQNameModule(), "addresses"));
+ BAZ.getQNameModule(), "addresses"));
assertNotNull(addresses_g);
assertIsAddedByUses(addresses_g, false);
assertFalse(addresses_u.equals(addresses_g));
assertEquals(addresses_g, extractOriginal(addresses_u));
// grouping defined by 'uses'
- final Collection<? extends GroupingDefinition> groupings_u = foo.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_u = FOO.getGroupings();
assertEquals(0, groupings_u.size());
// grouping defined in 'grouping' node
@Test
public void testCascadeUses() throws Exception {
- ctx = TestUtils.parseYangSource("/grouping-test/cascade-uses.yang");
- assertEquals(1, ctx.getModules().size());
+ final EffectiveModelContext loadModules = TestUtils.parseYangSource("/grouping-test/cascade-uses.yang");
+ assertEquals(1, loadModules.getModules().size());
- final Module testModule = TestUtils.findModule(ctx, "cascade-uses").get();
+ final Module testModule = Iterables.getOnlyElement(loadModules.findModules("cascade-uses"));
final QNameModule namespace = testModule.getQNameModule();
final Collection<? extends GroupingDefinition> groupings = testModule.getGroupings();
// grouping-V/container-grouping-V
assertNotNull(containerGroupingV);
assertFalse(containerGroupingV.isAddedByUses());
- SchemaPath expectedPath = createPath(true, expectedModule, "grouping-V", "container-grouping-V");
- assertPathEquals(expectedPath, containerGroupingV);
+ assertEquals(QName.create(expectedModule, "container-grouping-V"), containerGroupingV.getQName());
childNodes = containerGroupingV.getChildNodes();
assertEquals(2, childNodes.size());
for (final DataSchemaNode childNode : childNodes) {
// grouping-V/container-grouping-V/leaf-grouping-X
final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(
QName.create(namespace, "leaf-grouping-X"));
- expectedPath = createPath(true, expectedModule, "grouping-V", "container-grouping-V",
- "leaf-grouping-X");
- assertPathEquals(expectedPath, leafXinContainerV);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-X"), leafXinContainerV.getQName());
// grouping-V/container-grouping-V/leaf-grouping-Y
final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(
QName.create(namespace, "leaf-grouping-Y"));
- expectedPath = createPath(true, expectedModule, "grouping-V", "container-grouping-V",
- "leaf-grouping-Y");
- assertPathEquals(expectedPath, leafYinContainerV);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-Y"), leafYinContainerV.getQName());
// grouping-X
childNodes = gx.getChildNodes();
final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(
QName.create(namespace, "leaf-grouping-X"));
assertFalse(leafXinGX.isAddedByUses());
- expectedPath = createPath(true, expectedModule, "grouping-X", "leaf-grouping-X");
- assertPathEquals(expectedPath, leafXinGX);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-X"), leafXinGX.getQName());
// grouping-X/leaf-grouping-Y
final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(
QName.create(namespace, "leaf-grouping-Y"));
assertTrue(leafYinGX.isAddedByUses());
- expectedPath = createPath(true, expectedModule, "grouping-X", "leaf-grouping-Y");
- assertPathEquals(expectedPath, leafYinGX);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-Y"), leafYinGX.getQName());
// grouping-Y
childNodes = gy.getChildNodes();
final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(
QName.create(namespace, "leaf-grouping-Y"));
assertFalse(leafYinGY.isAddedByUses());
- expectedPath = createPath(true, expectedModule, "grouping-Y", "leaf-grouping-Y");
- assertPathEquals(expectedPath, leafYinGY);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-Y"), leafYinGY.getQName());
// grouping-Z
childNodes = gz.getChildNodes();
final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(
QName.create(namespace, "leaf-grouping-Z"));
assertFalse(leafZinGZ.isAddedByUses());
- expectedPath = createPath(true, expectedModule, "grouping-Z", "leaf-grouping-Z");
- assertPathEquals(expectedPath, leafZinGZ);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-Z"), leafZinGZ.getQName());
// grouping-ZZ
childNodes = gzz.getChildNodes();
final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(
QName.create(namespace, "leaf-grouping-ZZ"));
assertFalse(leafZZinGZZ.isAddedByUses());
- expectedPath = createPath(true, expectedModule, "grouping-ZZ", "leaf-grouping-ZZ");
- assertPathEquals(expectedPath, leafZZinGZZ);
+ assertEquals(QName.create(expectedModule, "leaf-grouping-ZZ"), leafZZinGZZ.getQName());
// TEST getOriginal from grouping-U
assertEquals(gv.getDataChildByName(QName.create(namespace, "leaf-grouping-V")),
public void testAddedByUsesLeafTypeQName() throws Exception {
final EffectiveModelContext loadModules = TestUtils.parseYangSources("/added-by-uses-leaf-test");
assertEquals(2, loadModules.getModules().size());
- foo = TestUtils.findModule(loadModules, "foo").get();
- final Module imp = TestUtils.findModule(loadModules, "import-module").get();
+
+ final Module foo = Iterables.getOnlyElement(loadModules.findModules("foo"));
+ final Module imp = Iterables.getOnlyElement(loadModules.findModules("import-module"));
final LeafSchemaNode leaf = (LeafSchemaNode)
((ContainerSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "my-container")))
assertEquals(leaf.getType().getQName(), impType.getQName());
}
- private static SchemaPath createPath(final boolean absolute, final QNameModule module, final String... names) {
- return SchemaPath.create(
- Arrays.stream(names).map(name -> QName.create(module, name)).collect(Collectors.toList()), true);
- }
-
private static void assertIsAddedByUses(final GroupingDefinition node, final boolean expected) {
assertEquals(expected, node.isAddedByUses());
for (DataSchemaNode child : node.getChildNodes()) {
*/
package org.opendaylight.yangtools.yang.stmt;
-import static org.junit.Assert.assertEquals;
-
import com.google.common.io.Files;
import java.io.File;
import java.io.FileFilter;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Submodule;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
.orElse(null);
}
- /**
- * Assertion that a {@link SchemaNode} reports expected path. This method deals with {@link SchemaNode#getPath()}
- * being unavailable by comparing {@link SchemaNode#getQName()} to {@link SchemaPath#getLastComponent()}.
- *
- * @param expected Expected
- * @param node Node to examine
- * @throws AssertionError if the
- */
- public static void assertPathEquals(final SchemaPath expected, final SchemaNode node) {
- final SchemaPath actual;
- try {
- actual = node.getPath();
- } catch (UnsupportedOperationException e) {
- LOG.trace("Node {} does not support getPath()", node, e);
- assertEquals(expected.getLastComponent(), node.getQName());
- return;
- }
- assertEquals(expected, actual);
- }
-
private static CrossSourceStatementReactor getReactor(final YangParserConfiguration config) {
return YangParserConfiguration.DEFAULT.equals(config) ? RFC7950Reactors.defaultReactor()
: RFC7950Reactors.defaultReactorBuilder(config).build();
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import java.io.IOException;
import java.net.URISyntaxException;
-import java.util.ArrayDeque;
import java.util.Collection;
-import java.util.Deque;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
public void testAugmentInUses() throws Exception {
final Module testModule = TestUtils.findModule(context, "uses-grouping").get();
- final Deque<QName> path = new ArrayDeque<>();
-
// * notification pcreq
final Collection<? extends NotificationDefinition> notifications = testModule.getNotifications();
assertEquals(1, notifications.size());
final NotificationDefinition pcreq = notifications.iterator().next();
assertNotNull(pcreq);
- QName expectedQName = QName.create(UG, "pcreq");
- path.offer(expectedQName);
- SchemaPath expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, pcreq);
+ assertEquals(QName.create(UG, "pcreq"), pcreq.getQName());
Collection<? extends DataSchemaNode> childNodes = pcreq.getChildNodes();
assertEquals(4, childNodes.size());
// * |-- leaf version
LeafSchemaNode version = (LeafSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
"version"));
assertNotNull(version);
- expectedQName = QName.create(UG, "version");
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, version);
- expectedQName = QName.create(UG, "version");
- path.offer(expectedQName);
- assertEquals(expectedQName, version.getType().getQName());
+ assertEquals(QName.create(UG, "version"), version.getQName());
+ assertEquals(QName.create(UG, "version"), version.getType().getQName());
assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
assertTrue(version.isAddedByUses());
// * |-- leaf type
LeafSchemaNode type = (LeafSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
"type"));
assertNotNull(type);
- expectedQName = QName.create(UG, "type");
assertTrue(type.isAddedByUses());
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, type);
- expectedQName = QName.create(GD, "int-ext");
- path.offer(expectedQName);
- assertEquals(expectedQName, type.getType().getQName());
+ assertEquals(QName.create(UG, "type"), type.getQName());
+ assertEquals(QName.create(GD, "int-ext"), type.getType().getQName());
final UnionTypeDefinition union = (UnionTypeDefinition) type.getType().getBaseType();
- assertEquals(QName.create(expectedQName, "union"), union.getQName());
+ assertEquals(QName.create(GD, "union"), union.getQName());
assertEquals(2, union.getTypes().size());
// * |-- list requests
final ListSchemaNode requests = (ListSchemaNode) pcreq.getDataChildByName(QName.create(
testModule.getQNameModule(), "requests"));
assertNotNull(requests);
- expectedQName = QName.create(UG, "requests");
- assertEquals(expectedQName, requests.getQName());
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, requests);
+ assertEquals(QName.create(UG, "requests"), requests.getQName());
assertFalse(requests.isAddedByUses());
childNodes = requests.getChildNodes();
assertEquals(3, childNodes.size());
final ContainerSchemaNode rp = (ContainerSchemaNode) requests.getDataChildByName(QName.create(
testModule.getQNameModule(), "rp"));
assertNotNull(rp);
- expectedQName = QName.create(UG, "rp");
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, rp);
+ assertEquals(QName.create(UG, "rp"), rp.getQName());
assertFalse(rp.isAddedByUses());
childNodes = rp.getChildNodes();
assertEquals(4, childNodes.size());
LeafSchemaNode processingRule = (LeafSchemaNode) rp.getDataChildByName(QName.create(
testModule.getQNameModule(), "processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- leaf ignore
LeafSchemaNode ignore = (LeafSchemaNode) rp.getDataChildByName(QName.create(testModule.getQNameModule(),
"ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- leaf priority
final LeafSchemaNode priority = (LeafSchemaNode) rp.getDataChildByName(QName.create(
testModule.getQNameModule(), "priority"));
assertNotNull(priority);
- expectedQName = QName.create(UG, "priority");
- assertEquals(expectedQName, priority.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, priority);
- expectedQName = QName.create(UG, "uint8");
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
+ assertEquals(QName.create(UG, "priority"), priority.getQName());
// TODO
- // assertEquals(expectedPath, priority.getType().getPath());
+ // assertEquals(QName.create(UG, "uint8"), priority.getType().getQName());
assertEquals(BaseTypes.uint8Type(), priority.getType().getBaseType());
assertTrue(priority.isAddedByUses());
// * |-- |-- |-- container box
ContainerSchemaNode box = (ContainerSchemaNode) rp.getDataChildByName(QName.create(testModule.getQNameModule(),
"box"));
assertNotNull(box);
- expectedQName = QName.create(UG, "box");
- assertEquals(expectedQName, box.getQName());
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, box);
+ assertEquals(QName.create(UG, "box"), box.getQName());
assertTrue(box.isAddedByUses());
// * |-- |-- |-- |-- container order
final ContainerSchemaNode order = (ContainerSchemaNode) box.getDataChildByName(QName.create(
testModule.getQNameModule(), "order"));
assertNotNull(order);
- expectedQName = QName.create(UG, "order");
- assertEquals(expectedQName, order.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, order);
+ assertEquals(QName.create(UG, "order"), order.getQName());
assertTrue(order.isAddedByUses());
assertTrue(order.isAugmenting());
assertEquals(2, order.getChildNodes().size());
final LeafSchemaNode delete = (LeafSchemaNode) order.getDataChildByName(QName.create(
testModule.getQNameModule(), "delete"));
assertNotNull(delete);
- expectedQName = QName.create(UG, "delete");
- assertEquals(expectedQName, delete.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, delete);
+ assertEquals(QName.create(UG, "delete"), delete.getQName());
assertEquals(BaseTypes.uint32Type(), delete.getType());
assertTrue(delete.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf setup
final LeafSchemaNode setup = (LeafSchemaNode) order.getDataChildByName(QName.create(
testModule.getQNameModule(), "setup"));
assertNotNull(setup);
- expectedQName = QName.create(UG, "setup");
- assertEquals(expectedQName, setup.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, setup);
+ assertEquals(QName.create(UG, "setup"), setup.getQName());
assertEquals(BaseTypes.uint32Type(), setup.getType());
assertTrue(setup.isAddedByUses());
// * |-- |-- path-key-expansion
final ContainerSchemaNode pke = (ContainerSchemaNode) requests.getDataChildByName(QName.create(
testModule.getQNameModule(), "path-key-expansion"));
assertNotNull(pke);
- expectedQName = QName.create(UG, "path-key-expansion");
- assertEquals(expectedQName, pke.getQName());
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, pke);
+ assertEquals(QName.create(UG, "path-key-expansion"), pke.getQName());
assertFalse(pke.isAddedByUses());
// * |-- |-- |-- path-key
final ContainerSchemaNode pathKey = (ContainerSchemaNode) pke.getDataChildByName(QName.create(
testModule.getQNameModule(), "path-key"));
assertNotNull(pathKey);
- expectedQName = QName.create(UG, "path-key");
- assertEquals(expectedQName, pathKey.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, pathKey);
+ assertEquals(QName.create(UG, "path-key"), pathKey.getQName());
assertFalse(pathKey.isAddedByUses());
assertEquals(3, pathKey.getChildNodes().size());
// * |-- |-- |-- |-- leaf processing-rule
processingRule = (LeafSchemaNode) pathKey.getDataChildByName(QName.create(testModule.getQNameModule(),
"processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- leaf ignore
ignore = (LeafSchemaNode) pathKey.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- |-- list path-keys
final ListSchemaNode pathKeys = (ListSchemaNode) pathKey.getDataChildByName(QName.create(
testModule.getQNameModule(), "path-keys"));
assertNotNull(pathKeys);
- expectedQName = QName.create(UG, "path-keys");
- assertEquals(expectedQName, pathKeys.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, pathKeys);
+ assertEquals(QName.create(UG, "path-keys"), pathKeys.getQName());
assertTrue(pathKeys.isAddedByUses());
childNodes = pathKeys.getChildNodes();
assertEquals(2, childNodes.size());
// * |-- |-- |-- |-- |-- leaf version
version = (LeafSchemaNode) pathKeys.getDataChildByName(QName.create(testModule.getQNameModule(), "version"));
assertNotNull(version);
- expectedQName = QName.create(UG, "version");
- assertEquals(expectedQName, version.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, version);
+ assertEquals(QName.create(UG, "version"), version.getQName());
assertTrue(version.getType() instanceof Uint8TypeDefinition);
assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
assertTrue(version.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf type
type = (LeafSchemaNode) pathKeys.getDataChildByName(QName.create(testModule.getQNameModule(), "type"));
assertNotNull(type);
- expectedQName = QName.create(UG, "type");
- assertEquals(expectedQName, type.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, type);
+ assertEquals(QName.create(UG, "type"), type.getQName());
assertTrue(type.getType() instanceof UnionTypeDefinition);
assertTrue(type.isAddedByUses());
assertTrue(type.isAugmenting());
final ContainerSchemaNode sc = (ContainerSchemaNode) requests.getDataChildByName(QName.create(
testModule.getQNameModule(), "segment-computation"));
assertNotNull(sc);
- expectedQName = QName.create(UG, "segment-computation");
- assertEquals(expectedQName, sc.getQName());
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, sc);
+ assertEquals(QName.create(UG, "segment-computation"), sc.getQName());
assertFalse(sc.isAddedByUses());
// * |-- |-- |-- container p2p
final ContainerSchemaNode p2p = (ContainerSchemaNode) sc.getDataChildByName(QName.create(
testModule.getQNameModule(), "p2p"));
assertNotNull(p2p);
- expectedQName = QName.create(UG, "p2p");
- assertEquals(expectedQName, p2p.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, p2p);
+ assertEquals(QName.create(UG, "p2p"), p2p.getQName());
assertFalse(p2p.isAddedByUses());
// * |-- |-- |-- |-- container endpoints
final ContainerSchemaNode endpoints = (ContainerSchemaNode) p2p.getDataChildByName(QName.create(
testModule.getQNameModule(), "endpoints"));
assertNotNull(endpoints);
- expectedQName = QName.create(UG, "endpoints");
- assertEquals(expectedQName, endpoints.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, endpoints);
+ assertEquals(QName.create(UG, "endpoints"), endpoints.getQName());
assertFalse(endpoints.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf processing-rule
processingRule = (LeafSchemaNode) endpoints.getDataChildByName(QName.create(testModule.getQNameModule(),
"processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore
ignore = (LeafSchemaNode) endpoints.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- |-- |-- container box
box = (ContainerSchemaNode) endpoints.getDataChildByName(QName.create(testModule.getQNameModule(), "box"));
assertNotNull(box);
- expectedQName = QName.create(UG, "box");
- assertEquals(expectedQName, box.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, box);
+ assertEquals(QName.create(UG, "box"), box.getQName());
assertTrue(box.isAddedByUses());
// * |-- |-- |-- |-- |-- choice address-family
final ChoiceSchemaNode af = (ChoiceSchemaNode) endpoints.getDataChildByName(QName.create(
testModule.getQNameModule(), "address-family"));
assertNotNull(af);
- expectedQName = QName.create(UG, "address-family");
- assertEquals(expectedQName, af.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, af);
+ assertEquals(QName.create(UG, "address-family"), af.getQName());
assertTrue(af.isAddedByUses());
// * |-- |-- |-- |-- container reported-route
final ContainerSchemaNode reportedRoute = (ContainerSchemaNode) p2p.getDataChildByName(QName.create(
testModule.getQNameModule(), "reported-route"));
assertNotNull(reportedRoute);
- expectedQName = QName.create(UG, "reported-route");
- assertEquals(expectedQName, reportedRoute.getQName());
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, reportedRoute);
+ assertEquals(QName.create(UG, "reported-route"), reportedRoute.getQName());
assertFalse(reportedRoute.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf processing-rule
processingRule = (LeafSchemaNode) reportedRoute.getDataChildByName(QName.create(testModule.getQNameModule(),
"processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore
ignore = (LeafSchemaNode) reportedRoute.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- |-- |-- list subobjects
final ListSchemaNode subobjects = (ListSchemaNode) reportedRoute.getDataChildByName(QName.create(
testModule.getQNameModule(), "subobjects"));
assertNotNull(subobjects);
- expectedQName = QName.create(UG, "subobjects");
- assertEquals(expectedQName, subobjects.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, subobjects);
+ assertEquals(QName.create(UG, "subobjects"), subobjects.getQName());
assertTrue(subobjects.isAddedByUses());
// * |-- |-- |-- |-- |-- container bandwidth
ContainerSchemaNode bandwidth = (ContainerSchemaNode) reportedRoute.getDataChildByName(QName.create(
testModule.getQNameModule(), "bandwidth"));
assertNotNull(bandwidth);
- expectedQName = QName.create(UG, "bandwidth");
- assertEquals(expectedQName, bandwidth.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, bandwidth);
+ assertEquals(QName.create(UG, "bandwidth"), bandwidth.getQName());
assertFalse(bandwidth.isAddedByUses());
// * |-- |-- |-- |-- container bandwidth
bandwidth = (ContainerSchemaNode) p2p
.getDataChildByName(QName.create(testModule.getQNameModule(), "bandwidth"));
assertNotNull(bandwidth);
- expectedQName = QName.create(UG, "bandwidth");
- assertEquals(expectedQName, bandwidth.getQName());
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, bandwidth);
+ assertEquals(QName.create(UG, "bandwidth"), bandwidth.getQName());
assertTrue(bandwidth.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf processing-rule
processingRule = (LeafSchemaNode) bandwidth.getDataChildByName(QName.create(testModule.getQNameModule(),
"processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore
ignore = (LeafSchemaNode) bandwidth.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- |-- |-- container bandwidth
final ContainerSchemaNode bandwidthInner = (ContainerSchemaNode) bandwidth.getDataChildByName(QName.create(
testModule.getQNameModule(), "bandwidth"));
assertNotNull(bandwidthInner);
- expectedQName = QName.create(UG, "bandwidth");
- assertEquals(expectedQName, bandwidth.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, bandwidthInner);
+ assertEquals(QName.create(UG, "bandwidth"), bandwidth.getQName());
assertTrue(bandwidthInner.isAddedByUses());
// * |-- list svec
final ListSchemaNode svec = (ListSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
"svec"));
assertNotNull(svec);
- expectedQName = QName.create(UG, "svec");
- assertEquals(expectedQName, svec.getQName());
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, svec);
+ assertEquals(QName.create(UG, "svec"), svec.getQName());
assertFalse(svec.isAddedByUses());
// * |-- |-- leaf link-diverse
final LeafSchemaNode linkDiverse = (LeafSchemaNode) svec.getDataChildByName(QName.create(
testModule.getQNameModule(), "link-diverse"));
assertNotNull(linkDiverse);
- expectedQName = QName.create(UG, "link-diverse");
- assertEquals(expectedQName, linkDiverse.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, linkDiverse);
+ assertEquals(QName.create(UG, "link-diverse"), linkDiverse.getQName());
assertEquals(BaseTypes.booleanType(), linkDiverse.getType().getBaseType());
assertTrue(linkDiverse.isAddedByUses());
// * |-- |-- leaf processing-rule
processingRule = (LeafSchemaNode) svec.getDataChildByName(QName.create(testModule.getQNameModule(),
"processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- leaf ignore
ignore = (LeafSchemaNode) svec.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- list metric
final ListSchemaNode metric = (ListSchemaNode) svec.getDataChildByName(QName.create(
testModule.getQNameModule(), "metric"));
assertNotNull(metric);
- expectedQName = QName.create(UG, "metric");
- assertEquals(expectedQName, metric.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, metric);
+ assertEquals(QName.create(UG, "metric"), metric.getQName());
assertFalse(metric.isAddedByUses());
// * |-- |-- |-- leaf metric-type
final LeafSchemaNode metricType = (LeafSchemaNode) metric.getDataChildByName(QName.create(
testModule.getQNameModule(), "metric-type"));
assertNotNull(metricType);
- expectedQName = QName.create(UG, "metric-type");
- assertEquals(expectedQName, metricType.getQName());
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, metricType);
+ assertEquals(QName.create(UG, "metric-type"), metricType.getQName());
assertEquals(BaseTypes.uint8Type(), metricType.getType());
assertTrue(metricType.isAddedByUses());
// * |-- |-- |-- box
box = (ContainerSchemaNode) metric.getDataChildByName(QName.create(testModule.getQNameModule(), "box"));
assertNotNull(box);
- expectedQName = QName.create(UG, "box");
- assertEquals(expectedQName, box.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, box);
+ assertEquals(QName.create(UG, "box"), box.getQName());
assertTrue(box.isAddedByUses());
// * |-- |-- |-- leaf processing-rule
processingRule = (LeafSchemaNode) metric.getDataChildByName(QName.create(testModule.getQNameModule(),
"processing-rule"));
assertNotNull(processingRule);
- expectedQName = QName.create(UG, "processing-rule");
- assertEquals(expectedQName, processingRule.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, processingRule);
+ assertEquals(QName.create(UG, "processing-rule"), processingRule.getQName());
assertEquals(BaseTypes.booleanType(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- leaf ignore
ignore = (LeafSchemaNode) metric.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
assertNotNull(ignore);
- expectedQName = QName.create(UG, "ignore");
- assertEquals(expectedQName, ignore.getQName());
- path.pollLast();
- path.offer(expectedQName);
- expectedPath = SchemaPath.create(path, true);
- assertPathEquals(expectedPath, ignore);
+ assertEquals(QName.create(UG, "ignore"), ignore.getQName());
assertEquals(BaseTypes.booleanType(), ignore.getType());
assertTrue(ignore.isAddedByUses());
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
-import java.util.ArrayList;
import java.util.Collection;
-import java.util.List;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
public class YangParserSimpleTest {
- private static final QNameModule SN = QNameModule.create(XMLNamespace.of("urn:opendaylight:simple-nodes"),
- Revision.of("2013-07-30"));
+ private static final XMLNamespace NS = XMLNamespace.of("urn:opendaylight:simple-nodes");
+ private static final QNameModule SN = QNameModule.create(NS, Revision.of("2013-07-30"));
private static final QName SN_NODES = QName.create(SN, "nodes");
- private static final SchemaPath SN_NODES_PATH = SchemaPath.create(true, SN_NODES);
private SchemaContext context;
private Module testModule;
.getDataChildByName(QName.create(testModule.getQNameModule(), "nodes"));
// test SchemaNode args
assertEquals(SN_NODES, nodes.getQName());
- assertPathEquals(SN_NODES_PATH, nodes);
assertEquals(Optional.of("nodes collection"), nodes.getDescription());
assertEquals(Optional.of("nodes ref"), nodes.getReference());
assertEquals(Status.CURRENT, nodes.getStatus());
assertEquals(8, nodes.getChildNodes().size());
final LeafListSchemaNode added = (LeafListSchemaNode)nodes.getDataChildByName(QName.create(
testModule.getQNameModule(), "added"));
- assertPathEquals(createPath("nodes", "added"), added);
- assertEquals(createPath("mytype").getLastComponent(), added.getType().getQName());
+ assertEquals(QName.create(SN, "added"), added.getQName());
+ assertEquals(QName.create(SN, "mytype"), added.getType().getQName());
final ListSchemaNode links = (ListSchemaNode) nodes.getDataChildByName(QName.create(
testModule.getQNameModule(), "links"));
final UsesNode use = uses.iterator().next();
assertEquals(nodeGroup, use.getSourceGrouping());
}
-
-
- private static final XMLNamespace NS = XMLNamespace.of("urn:opendaylight:simple-nodes");
-
- private static SchemaPath createPath(final String... names) {
- final Revision rev = Revision.of("2013-07-30");
- final List<QName> path = new ArrayList<>();
- for (final String name : names) {
- path.add(QName.create(NS, rev, name));
- }
- return SchemaPath.create(path, true);
- }
-
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import com.google.common.collect.Range;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
// test SchemaNode args
assertEquals(QName.create(BAR, "ifEntry"), ifEntry.getQName());
- assertPathEquals(SchemaPath.create(true, QName.create(BAR, "interfaces"), QName.create(BAR, "ifEntry")),
- ifEntry);
assertFalse(ifEntry.getDescription().isPresent());
assertFalse(ifEntry.getReference().isPresent());
assertEquals(Status.CURRENT, ifEntry.getStatus());
final NotificationDefinition notification = notifications.iterator().next();
// test SchemaNode args
assertEquals(QName.create(BAZ, "event"), notification.getQName());
- final SchemaPath expectedPath = SchemaPath.create(true, QName.create(BAZ, "event"));
- assertPathEquals(expectedPath, notification);
assertFalse(notification.getDescription().isPresent());
assertFalse(notification.getReference().isPresent());
assertEquals(Status.CURRENT, notification.getStatus());
package org.opendaylight.yangtools.yang.thirdparty.plugin;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class ThirdPartyExtensionEffectiveStatementImpl
extends UnknownEffectiveStatementBase<String, ThirdPartyExtensionStatement>
implements ThirdPartyExtensionEffectiveStatement {
-
- private final @Nullable SchemaPath path;
private final String valueFromNamespace;
ThirdPartyExtensionEffectiveStatementImpl(final Current<String, ThirdPartyExtensionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
valueFromNamespace = stmt.getFromNamespace(ThirdPartyNamespace.class, Empty.getInstance());
}
return getNodeType();
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public ThirdPartyExtensionEffectiveStatement asEffectiveStatement() {
return this;
public boolean canReuseCurrent(final Current<QName, D> copy, final Current<QName, D> current,
final Collection<? extends EffectiveStatement<?, ?>> substatements) {
return equalHistory(copy.history(), current.history())
- && copy.getArgument().equals(current.getArgument())
- // FIXME: 8.0.0: eliminate this call
- && copy.equalParentPath(current);
+ && copy.getArgument().equals(current.getArgument());
}
private static boolean equalHistory(final CopyHistory copy, final CopyHistory current) {
* Return the {@link StatementPolicy} corresponding to a potentially-instantiated YANG statement. Statements are
* reused as long as:
* <ul>
- * <li>{@link Current#schemaPath()} does not change</li>
* <li>{@link Current#argument()} does not change</li>
* <li>{@link Current#history()} does not change as far as {@link CopyableNode} is concerned</li>
* <li>{@link Current#effectiveConfig()} does not change</li>
* Return the {@link StatementPolicy} corresponding to an uninstantiated YANG statement. Statements are
* reused as long as:
* <ul>
- * <li>{@link Current#schemaPath()} does not change</li>
* <li>{@link Current#argument()} does not change</li>
* <li>{@link Current#history()} does not change as far as {@link CopyableNode} is concerned</li>
* </ul>
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
// FIXME: 7.0.0: this is currently only used by AbstractTypeStatement
@NonNull QNameModule effectiveNamespace();
-
- /**
- * Return the effective path of this statement. This method is intended for use with statements which naturally
- * have a {@link QName} identifier and this identifier forms the ultimate step in their
- * {@link SchemaNode#getPath()}.
- *
- * <p>
- * Returned object conforms to {@link SchemaPathSupport}'s view of how these are to be handled. Users of this
- * method are expected to consult {@link SchemaNodeDefaults#extractQName(Immutable)} and
- * {@link SchemaNodeDefaults#extractPath(Object, Immutable)} to ensure correct implementation behaviour with
- * respect to {@link SchemaNode#getQName()} and {@link SchemaNode#getPath()} respectively.
- *
- * @return An {@link Immutable} effective path object
- */
- // FIXME: Remove this when SchemaNode.getPath() is removed. QName users will store getArgument() instead.
- default @NonNull Immutable effectivePath() {
- return SchemaPathSupport.toEffectivePath(getSchemaPath());
- }
-
- /**
- * Return an optional-to-provide path for {@link SchemaNode#getPath()}. The result of this method is expected
- * to be consulted with {@link SchemaNodeDefaults#throwUnsupportedIfNull(Object, SchemaPath)} to get consistent
- * API behaviour.
- *
- * @return Potentially-null {@link SchemaPath}.
- */
- // FIXME: Remove this when SchemaNode.getPath() is removed
- default @Nullable SchemaPath optionalPath() {
- return SchemaPathSupport.toOptionalPath(getSchemaPath());
- }
-
- /**
- * Return the {@link SchemaNode#getPath()} of this statement. Not all statements have a SchemaPath, in which
- * case null is returned.
- *
- * @return SchemaPath or null
- */
- // FIXME: Remove this when SchemaNode.getPath() is removed
- @Nullable SchemaPath schemaPath();
-
- /**
- * Return the {@link SchemaNode#getPath()} of this statement, failing if it is not present.
- *
- * @return A SchemaPath.
- * @throws VerifyException if {@link #schemaPath()} returns null
- */
- // FIXME: Remove this when SchemaNode.getPath() is removed
- default @NonNull SchemaPath getSchemaPath() {
- return verifyNotNull(schemaPath(), "Missing path for %s", this);
- }
}
/**
// FIXME: YANGTOOLS-1186: lob the Holy Hand Grenade of Antioch
@Deprecated
<E extends EffectiveStatement<A, D>> @NonNull StmtContext<A, D, E> caerbannog();
-
- /**
- * Compare another context for equality of {@code getEffectiveParent().getSchemaPath()}, just in a safer manner.
- *
- * @param other Other {@link Current}
- * @return True if {@code other} has parent path equal to this context's parent path.
- */
- // FIXME: Remove this when SchemaNode.getPath() is removed
- default boolean equalParentPath(final Current<A, D> other) {
- final Parent ours = effectiveParent();
- final Parent theirs = other.effectiveParent();
- return ours == theirs
- || ours != null && theirs != null && SchemaPathSupport.effectivelyEqual(
- ours.schemaPath(), theirs.schemaPath());
- }
}
}
+++ /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.spi.meta;
-
-import com.google.common.annotations.Beta;
-import java.util.Objects;
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-
-@Beta
-// FIXME: remove this class once we ditch SchemaPath.getPath()
-public abstract class SchemaPathSupport implements Immutable {
- private static final class Enabled extends SchemaPathSupport {
- @Override
- SchemaPath effectivePath(final SchemaPath path) {
- return path;
- }
-
- @Override
- SchemaPath optionalPath(final SchemaPath path) {
- return path;
- }
-
- @Override
- boolean equalPaths(final SchemaPath first, final SchemaPath second) {
- return Objects.equals(first, second);
- }
- }
-
- private static final SchemaPathSupport DEFAULT = new Enabled();
-
- private SchemaPathSupport() {
- // Hidden on purpose
- }
-
- public static @NonNull Immutable toEffectivePath(final @NonNull SchemaPath path) {
- return DEFAULT.effectivePath(path);
- }
-
- public static @Nullable SchemaPath toOptionalPath(final @Nullable SchemaPath path) {
- return DEFAULT.optionalPath(path);
- }
-
- public static boolean effectivelyEqual(@Nullable final SchemaPath first, @Nullable final SchemaPath second) {
- return DEFAULT.equalPaths(first, second);
- }
-
- abstract boolean equalPaths(@Nullable SchemaPath first, @Nullable SchemaPath second);
-
- abstract @NonNull Immutable effectivePath(@NonNull SchemaPath path);
-
- abstract @Nullable SchemaPath optionalPath(@Nullable SchemaPath path);
-}
Code Review / yangtools.git / commitdiff