final Current<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueEffectiveStatement;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement;
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.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
extends UnknownEffectiveStatementBase<Void, OpenConfigHashedValueStatement>
implements OpenConfigHashedValueEffectiveStatement {
private final @NonNull StatementDefinition definition;
- private final SchemaPath path;
+ private final @NonNull Object path;
Effective(final Current<Void, OpenConfigHashedValueStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
definition = stmt.publicDefinition();
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
.createChild(stmt.publicDefinition().getStatementName()));
}
@Override
public QName getQName() {
- return path.getLastComponent();
+ return SchemaPathSupport.extractQName(path);
}
@Override
@Deprecated
public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ return SchemaPathSupport.extractPath(this, path);
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
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.rfc6241.model.api.NetconfStatements;
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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
private static final class Effective
extends UnknownEffectiveStatementBase<Void, GetFilterElementAttributesStatement>
implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
Effective(final Current<Void, GetFilterElementAttributesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
.createChild(stmt.publicDefinition().getStatementName()));
}
@Override
public QName getQName() {
- return path.getLastComponent();
+ return SchemaPathSupport.extractQName(path);
}
@Override
@Deprecated
public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ return SchemaPathSupport.extractPath(this, path);
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
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.rfc6536.model.api.NACMStatements;
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.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
private static final class Effective extends UnknownEffectiveStatementBase<Void, DefaultDenyAllStatement>
implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
Effective(final Current<Void, DefaultDenyAllStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
.createChild(stmt.publicDefinition().getStatementName()));
}
@Override
public QName getQName() {
- return path.getLastComponent();
+ return SchemaPathSupport.extractQName(path);
}
@Override
@Deprecated
public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ return SchemaPathSupport.extractPath(this, path);
}
@Override
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
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.rfc6536.model.api.NACMStatements;
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.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
private static final class Effective extends UnknownEffectiveStatementBase<Void, DefaultDenyWriteStatement>
implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
Effective(final Current<Void, DefaultDenyWriteStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
.createChild(stmt.publicDefinition().getStatementName()));
}
@Override
public QName getQName() {
- return path.getLastComponent();
+ return SchemaPathSupport.extractQName(path);
}
@Override
@Deprecated
public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ return SchemaPathSupport.extractPath(this, path);
}
@Override
AliasEffectiveStatementImpl(final Current<String, AliasStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
DefValEffectiveStatementImpl(final Current<String, DefValStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
DisplayHintEffectiveStatementImpl(final Current<String, DisplayHintStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
ImpliedEffectiveStatementImpl(final Current<String, ImpliedStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
MaxAccessEffectiveStatementImpl(final Current<MaxAccess, MaxAccessStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
OidEffectiveStatementImpl(final Current<ObjectIdentifier, OidStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
SubIdEffectiveStatementImpl(final Current<Uint32, SubIdStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
}
type = builder.build();
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(qname));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(qname));
}
@Override
super(stmt, substatements);
this.argumentQName = requireNonNull(qname);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(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
@Override
protected MountPointEffectiveStatement createEffective(final Current<QName, MountPointStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new MountPointEffectiveStatementImpl(stmt, substatements,
- SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(stmt.getArgument())));
+ return new MountPointEffectiveStatementImpl(stmt, substatements, SchemaPathSupport.toOptionalPath(
+ stmt.getEffectiveParent().getSchemaPath().createChild(stmt.getArgument())));
}
}
OpenConfigVersionEffectiveStatementImpl(final Current<SemVer, OpenConfigVersionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
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.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;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
/**
*/
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
@Override
default QName getQName() {
- return getPath().getLastComponent();
+ return SchemaPathSupport.extractQName(pathObject());
}
+
+ @Override
+ @Deprecated
+ default SchemaPath getPath() {
+ return SchemaPathSupport.extractPath(this, pathObject());
+ }
+
+ @NonNull Object pathObject();
}
/**
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
-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.stmt.ActionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
final class ActionEffectiveStatementImpl extends WithSubstatements<QName, ActionStatement, ActionEffectiveStatement>
implements ActionDefinition, ActionEffectiveStatement, OperationDefinitionMixin<ActionStatement>,
CopyableMixin<QName, ActionStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
- ActionEffectiveStatementImpl(final ActionStatement declared, final SchemaPath path, final int flags,
+ ActionEffectiveStatementImpl(final ActionStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, substatements);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
- ActionEffectiveStatementImpl(final ActionEffectiveStatementImpl original, final SchemaPath path, final int flags) {
+ ActionEffectiveStatementImpl(final ActionEffectiveStatementImpl original, final Object path, final int flags) {
super(original);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
verify(!substatements.isEmpty(), "Missing implicit input/output statements at %s", ref);
try {
- return new ActionEffectiveStatementImpl(stmt.declared(), stmt.wrapSchemaPath(),
+ return new ActionEffectiveStatementImpl(stmt.declared(), stmt.effectivePath(),
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 new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, stmt.wrapSchemaPath(),
+ return new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, stmt.effectivePath(),
EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()));
}
}
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
.setConfiguration(stmt.effectiveConfig().asNullable())
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
- final SchemaPath path = stmt.wrapSchemaPath();
+ final Object path = stmt.effectivePath();
return substatements.isEmpty()
? new EmptyAnydataEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt))
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anydata;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
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.stmt.AnydataEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.Default;
class EmptyAnydataEffectiveStatement extends Default<QName, AnydataStatement>
implements AnydataEffectiveStatement, AnydataSchemaNode, OpaqueDataSchemaNodeMixin<AnydataStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final AnydataSchemaNode original;
private final int flags;
- EmptyAnydataEffectiveStatement(final AnydataStatement declared, final SchemaPath path, final int flags,
+ EmptyAnydataEffectiveStatement(final AnydataStatement declared, final Object path, final int flags,
final @Nullable AnydataSchemaNode original) {
super(declared);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.original = original;
}
@Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
-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.AnydataStatement;
final class RegularAnydataEffectiveStatement extends EmptyAnydataEffectiveStatement {
private final @NonNull Object substatements;
- RegularAnydataEffectiveStatement(final AnydataStatement declared, final SchemaPath path, final int flags,
+ RegularAnydataEffectiveStatement(final AnydataStatement declared, final Object path, final int flags,
final @Nullable AnydataSchemaNode original,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, path, flags, original);
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
.setConfiguration(stmt.effectiveConfig().asNullable())
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
- final SchemaPath path = stmt.wrapSchemaPath();
+ final Object path = stmt.effectivePath();
return substatements.isEmpty()
? new EmptyAnyxmlEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt))
- : new RegularAnyxmlEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt),substatements);
+ : new RegularAnyxmlEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt), substatements);
}
private static @Nullable AnyxmlSchemaNode findOriginal(final Current<?, ?> stmt) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anyxml;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.Default;
class EmptyAnyxmlEffectiveStatement extends Default<QName, AnyxmlStatement>
implements AnyxmlEffectiveStatement, AnyxmlSchemaNode, OpaqueDataSchemaNodeMixin<AnyxmlStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final AnyxmlSchemaNode original;
private final int flags;
- EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final SchemaPath path, final int flags,
+ EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final Object path, final int flags,
final @Nullable AnyxmlSchemaNode original) {
super(declared);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.original = original;
}
@Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-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.AnyxmlStatement;
final class RegularAnyxmlEffectiveStatement extends EmptyAnyxmlEffectiveStatement {
private final @NonNull Object substatements;
- RegularAnyxmlEffectiveStatement(final AnyxmlStatement declared, final SchemaPath path, final int flags,
+ RegularAnyxmlEffectiveStatement(final AnyxmlStatement declared, final Object path, final int flags,
final @Nullable AnyxmlSchemaNode original,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, path, flags, original);
@Override
protected CaseEffectiveStatement copyDeclaredEffective(final Current<QName, CaseStatement> stmt,
final CaseEffectiveStatement original) {
- return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original,
- computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(), findOriginal(stmt));
+ return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, stmt.effectivePath(),
+ computeFlags(stmt, original.effectiveSubstatements()), findOriginal(stmt));
}
@Override
protected CaseEffectiveStatement copyUndeclaredEffective(final Current<QName, CaseStatement> stmt,
final CaseEffectiveStatement original) {
- return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original,
- computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(), findOriginal(stmt));
+ return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, stmt.effectivePath(),
+ computeFlags(stmt, original.effectiveSubstatements()),findOriginal(stmt));
}
@Override
protected CaseEffectiveStatement createDeclaredEffective(final Current<QName, CaseStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new DeclaredCaseEffectiveStatement(stmt.declared(), substatements, computeFlags(stmt, substatements),
- stmt.wrapSchemaPath(), findOriginal(stmt));
+ return new DeclaredCaseEffectiveStatement(stmt.declared(), substatements, stmt.effectivePath(),
+ computeFlags(stmt, substatements), findOriginal(stmt));
} 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 new UndeclaredCaseEffectiveStatement(substatements, computeFlags(stmt, substatements),
- stmt.wrapSchemaPath(), findOriginal(stmt));
+ return new UndeclaredCaseEffectiveStatement(substatements, stmt.effectivePath(),
+ computeFlags(stmt, substatements), findOriginal(stmt));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.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.stmt.CaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
final class DeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
private final CaseSchemaNode original;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
DeclaredCaseEffectiveStatement(final CaseStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags,
+ final @Nullable CaseSchemaNode original) {
super(declared, substatements);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
this.original = original;
}
- DeclaredCaseEffectiveStatement(final DeclaredCaseEffectiveStatement origEffective, final int flags,
- final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ DeclaredCaseEffectiveStatement(final DeclaredCaseEffectiveStatement origEffective, final Object path,
+ final int flags, final @Nullable CaseSchemaNode original) {
super(origEffective);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
this.original = original;
}
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.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.stmt.CaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
final class UndeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
private final @Nullable CaseSchemaNode original;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
UndeclaredCaseEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final int flags, final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ final Object path, final int flags, final @Nullable CaseSchemaNode original) {
super(substatements);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.original = original;
}
- UndeclaredCaseEffectiveStatement(final UndeclaredCaseEffectiveStatement origEffective, final int flags,
- final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ UndeclaredCaseEffectiveStatement(final UndeclaredCaseEffectiveStatement origEffective, final Object path,
+ final int flags, final @Nullable CaseSchemaNode original) {
super(origEffective);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.original = original;
}
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
-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.stmt.ChoiceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
MandatoryMixin<QName, ChoiceStatement> {
private final CaseSchemaNode defaultCase;
private final ChoiceSchemaNode original;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
ChoiceEffectiveStatementImpl(final ChoiceStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final SchemaPath path, final @Nullable CaseSchemaNode defaultCase,
+ final Object path, final @Nullable CaseSchemaNode defaultCase,
final @Nullable ChoiceSchemaNode original) {
super(declared, substatements);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.defaultCase = defaultCase;
this.original = original;
}
ChoiceEffectiveStatementImpl(final ChoiceEffectiveStatementImpl origEffective, final int flags,
- final SchemaPath path, final ChoiceSchemaNode original) {
+ final Object path, final ChoiceSchemaNode original) {
super(origEffective);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.defaultCase = origEffective.defaultCase;
this.original = original;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
public ChoiceEffectiveStatement copyEffective(final Current<QName, ChoiceStatement> stmt,
final ChoiceEffectiveStatement original) {
return new ChoiceEffectiveStatementImpl((ChoiceEffectiveStatementImpl) original,
- computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(),
+ computeFlags(stmt, original.effectiveSubstatements()), stmt.effectivePath(),
(ChoiceSchemaNode) stmt.original());
}
try {
return new ChoiceEffectiveStatementImpl(stmt.declared(), substatements, computeFlags(stmt, substatements),
- stmt.wrapSchemaPath(), defaultCase, (ChoiceSchemaNode) stmt.original());
+ stmt.effectivePath(), defaultCase, (ChoiceSchemaNode) stmt.original());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
-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.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
AugmentationTargetMixin<QName, ContainerStatement> {
private final int flags;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final @Nullable ContainerSchemaNode original;
ContainerEffectiveStatementImpl(final ContainerStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final SchemaPath path, final ContainerSchemaNode original) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags,
+ final ContainerSchemaNode original) {
super(declared, substatements);
+ this.path = requireNonNull(path);
this.original = original;
this.flags = flags;
- this.path = path;
}
- ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective,
- final ContainerSchemaNode original, final int flags, final @Nullable SchemaPath path) {
+ ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective, final Object path,
+ final int flags, final ContainerSchemaNode original) {
super(origEffective);
+ this.path = requireNonNull(path);
this.original = original;
this.flags = flags;
- this.path = path;
}
@Override
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
EffectiveStmtUtils.checkUniqueUses(stmt, substatements);
try {
- return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, createFlags(stmt, substatements),
- stmt.wrapSchemaPath(), (ContainerSchemaNode) stmt.original());
+ return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, stmt.effectivePath(),
+ createFlags(stmt, substatements), (ContainerSchemaNode) stmt.original());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
@Override
public ContainerEffectiveStatement copyEffective(final Current<QName, ContainerStatement> stmt,
final ContainerEffectiveStatement original) {
- return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original,
- (ContainerSchemaNode) stmt.original(), createFlags(stmt, original.effectiveSubstatements()),
- stmt.wrapSchemaPath());
+ return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original, stmt.effectivePath(),
+ createFlags(stmt, original.effectiveSubstatements()), (ContainerSchemaNode) stmt.original());
}
private static int createFlags(final Current<?, ?> stmt,
try {
final ExtensionEffectiveStatementImpl created = new ExtensionEffectiveStatementImpl(stmt.declared(),
- stmt.wrapSchemaPath());
+ stmt.optionalPath());
verify(tl.put(stmt, created) == null);
try {
return super.createEffective(stmt, declaredSubstatements, effectiveSubstatements);
LOG.debug("Cannot construct path for {}, attempting to recover", stmt, e);
maybePath = null;
}
- path = SchemaPathSupport.wrap(maybePath);
+ path = SchemaPathSupport.toOptionalPath(maybePath);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.feature;
+import static java.util.Objects.requireNonNull;
+
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.Default;
class EmptyFeatureEffectiveStatement extends Default<QName, FeatureStatement>
implements FeatureDefinition, FeatureEffectiveStatement, SchemaNodeMixin<QName, FeatureStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
- EmptyFeatureEffectiveStatement(final FeatureStatement declared, final SchemaPath path, final int flags) {
+ EmptyFeatureEffectiveStatement(final FeatureStatement declared, final Object path, final int flags) {
super(declared);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
@Override
@Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
protected FeatureEffectiveStatement createEffective(final Current<QName, FeatureStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return substatements.isEmpty()
- ? new EmptyFeatureEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath(), EMPTY_EFFECTIVE_FLAGS)
- : new RegularFeatureEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath(),
+ ? new EmptyFeatureEffectiveStatement(stmt.declared(), stmt.effectivePath(), EMPTY_EFFECTIVE_FLAGS)
+ : new RegularFeatureEffectiveStatement(stmt.declared(), stmt.effectivePath(),
computeFlags(substatements), substatements);
}
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-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.FeatureStatement;
final class RegularFeatureEffectiveStatement extends EmptyFeatureEffectiveStatement {
private final @NonNull Object substatements;
- RegularFeatureEffectiveStatement(final FeatureStatement declared, final SchemaPath path, final int flags,
+ RegularFeatureEffectiveStatement(final FeatureStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, path, flags);
this.substatements = maskList(substatements);
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-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.stmt.GroupingEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
DataNodeContainerMixin<QName, GroupingStatement>,
SchemaNodeMixin<QName, GroupingStatement>, ActionNodeContainerMixin<QName, GroupingStatement>,
NotificationNodeContainerMixin<QName, GroupingStatement>, AddedByUsesMixin<QName, GroupingStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
GroupingEffectiveStatementImpl(final GroupingStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final SchemaPath path) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags) {
super(declared, substatements);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
return flags;
}
+ @Override
+ public Object pathObject() {
+ return path;
+ }
+
@Override
public QName argument() {
return getQName();
return dataSchemaNode(name);
}
- @Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
- }
-
@Override
public GroupingEffectiveStatement asEffectiveStatement() {
return this;
protected GroupingEffectiveStatement createEffective(final Current<QName, GroupingStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new GroupingEffectiveStatementImpl(stmt.declared(), substatements,
- EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements), stmt.wrapSchemaPath());
+ return new GroupingEffectiveStatementImpl(stmt.declared(), substatements, stmt.effectivePath(),
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument;
abstract class AbstractIdentityEffectiveStatement extends DefaultArgument<QName, IdentityStatement>
implements IdentityEffectiveStatement, IdentitySchemaNode, SchemaNodeMixin<QName, IdentityStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
- AbstractIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path) {
+ AbstractIdentityEffectiveStatement(final IdentityStatement declared, final Object path) {
super(declared);
- this.path = path;
+ this.path = requireNonNull(path);
}
@Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
final class EmptyIdentityEffectiveStatement extends AbstractIdentityEffectiveStatement {
private static final int CURRENT_FLAGS = new FlagsBuilder().setStatus(Status.CURRENT).toFlags();
- EmptyIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path) {
+ EmptyIdentityEffectiveStatement(final IdentityStatement declared, final Object path) {
super(declared, path);
}
protected IdentityEffectiveStatement createEffective(final Current<QName, IdentityStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
if (substatements.isEmpty()) {
- return new EmptyIdentityEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath());
+ return new EmptyIdentityEffectiveStatement(stmt.declared(), stmt.effectivePath());
}
final List<IdentitySchemaNode> identities = new ArrayList<>();
}
}
- return new RegularIdentityEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath(), new FlagsBuilder()
+ return new RegularIdentityEffectiveStatement(stmt.declared(), stmt.effectivePath(), new FlagsBuilder()
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags(), substatements, ImmutableSet.copyOf(identities));
}
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-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.IdentityStatement;
private final @NonNull Object substatements;
private final int flags;
- RegularIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path, final int flags,
+ RegularIdentityEffectiveStatement(final IdentityStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableSet<? extends IdentitySchemaNode> baseIdentities) {
super(declared, path);
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
-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.stmt.InputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
final class DeclaredInputEffectiveStatement extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
- DeclaredInputEffectiveStatement(final int flags, final InputStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
+ DeclaredInputEffectiveStatement(final InputStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags) {
super(declared, substatements);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
- DeclaredInputEffectiveStatement(final int flags, final DeclaredInputEffectiveStatement original,
- final SchemaPath path) {
+ DeclaredInputEffectiveStatement(final DeclaredInputEffectiveStatement original, final Object path,
+ final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
@Override
protected InputEffectiveStatement copyDeclaredEffective(final int flags,
final Current<QName, InputStatement> stmt, final InputEffectiveStatement original) {
- return new DeclaredInputEffectiveStatement(flags, (DeclaredInputEffectiveStatement) original,
- stmt.wrapSchemaPath());
+ return new DeclaredInputEffectiveStatement((DeclaredInputEffectiveStatement) original, stmt.effectivePath(),
+ flags);
}
@Override
protected InputEffectiveStatement copyUndeclaredEffective(final int flags,
final Current<QName, InputStatement> stmt, final InputEffectiveStatement original) {
- return new UndeclaredInputEffectiveStatement(flags, (UndeclaredInputEffectiveStatement) original,
- stmt.wrapSchemaPath());
+ return new UndeclaredInputEffectiveStatement((UndeclaredInputEffectiveStatement) original, stmt.effectivePath(),
+ flags);
}
@Override
protected InputEffectiveStatement createDeclaredEffective(final int flags,
final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DeclaredInputEffectiveStatement(flags, stmt.declared(), substatements, stmt.wrapSchemaPath());
+ return new DeclaredInputEffectiveStatement(stmt.declared(), substatements, stmt.effectivePath(), flags);
}
@Override
final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new UndeclaredInputEffectiveStatement(flags, substatements, stmt.wrapSchemaPath());
+ return new UndeclaredInputEffectiveStatement(substatements, stmt.effectivePath(), flags);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
-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.stmt.InputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
final class UndeclaredInputEffectiveStatement
extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
- UndeclaredInputEffectiveStatement(final int flags,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
+ UndeclaredInputEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final Object path, final int flags) {
super(substatements);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
- UndeclaredInputEffectiveStatement(final int flags, final UndeclaredInputEffectiveStatement original,
- final SchemaPath path) {
+ UndeclaredInputEffectiveStatement(final UndeclaredInputEffectiveStatement original, final Object path,
+ final int flags) {
super(original);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-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.DefaultEffectiveStatement;
DataSchemaNodeMixin<QName, LeafStatement>, MandatoryMixin<QName, LeafStatement>,
MustConstraintMixin<QName, LeafStatement> {
private final @NonNull Object substatements;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final @NonNull TypeDefinition<?> type;
private final int flags;
- AbstractLeafEffectiveStatement(final LeafStatement declared, final SchemaPath path, final int flags,
+ AbstractLeafEffectiveStatement(final LeafStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
+ this.path = requireNonNull(path);
this.substatements = maskList(substatements);
- this.path = path;
this.flags = flags;
// TODO: lazy instantiation?
this.type = buildType();
}
- AbstractLeafEffectiveStatement(final AbstractLeafEffectiveStatement original, final SchemaPath path,
+ AbstractLeafEffectiveStatement(final AbstractLeafEffectiveStatement original, final Object path,
final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.substatements = original.substatements;
- this.path = path;
this.flags = flags;
// FIXME: share with original?
this.type = buildType();
}
@Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
import com.google.common.collect.ImmutableList;
import java.util.Optional;
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.LeafStatement;
final class EmptyLeafEffectiveStatement extends AbstractLeafEffectiveStatement {
- EmptyLeafEffectiveStatement(final LeafStatement declared, final SchemaPath path, final int flags,
+ EmptyLeafEffectiveStatement(final LeafStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, path, flags, substatements);
}
- EmptyLeafEffectiveStatement(final EmptyLeafEffectiveStatement original, final SchemaPath path, final int flags) {
+ EmptyLeafEffectiveStatement(final EmptyLeafEffectiveStatement original, final Object path, final int flags) {
super(original, path, flags);
}
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Override
public LeafEffectiveStatement copyEffective(final Current<QName, LeafStatement> stmt,
final LeafEffectiveStatement original) {
- return new RegularLeafEffectiveStatement((AbstractLeafEffectiveStatement) original, stmt.wrapSchemaPath(),
+ return new RegularLeafEffectiveStatement((AbstractLeafEffectiveStatement) original, stmt.effectivePath(),
computeFlags(stmt, original.effectiveSubstatements()), (LeafSchemaNode) stmt.original());
}
final LeafSchemaNode original = (LeafSchemaNode) stmt.original();
final int flags = computeFlags(stmt, substatements);
final LeafStatement declared = stmt.declared();
- final SchemaPath path = stmt.wrapSchemaPath();
- return original == null ? new EmptyLeafEffectiveStatement(declared, path, flags, substatements)
- : new RegularLeafEffectiveStatement(declared, path, flags, substatements, original);
+ return original == null ? new EmptyLeafEffectiveStatement(declared, stmt.effectivePath(), flags, substatements)
+ : new RegularLeafEffectiveStatement(declared, stmt.effectivePath(), flags, substatements, original);
}
private static int computeFlags(final Current<?, ?> stmt,
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
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.LeafStatement;
final class RegularLeafEffectiveStatement extends AbstractLeafEffectiveStatement {
private final @Nullable LeafSchemaNode original;
- RegularLeafEffectiveStatement(final LeafStatement declared, final SchemaPath path, final int flags,
+ RegularLeafEffectiveStatement(final LeafStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final LeafSchemaNode original) {
super(declared, path, flags, substatements);
this.original = original;
}
- RegularLeafEffectiveStatement(final AbstractLeafEffectiveStatement originalEffective, final SchemaPath path,
+ RegularLeafEffectiveStatement(final AbstractLeafEffectiveStatement originalEffective, final Object path,
final int flags, final LeafSchemaNode original) {
super(originalEffective, path, flags);
this.original = original;
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-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.DescriptionEffectiveStatement;
UserOrderedMixin<QName, LeafListStatement>, DataSchemaNodeMixin<QName, LeafListStatement>,
MustConstraintMixin<QName, LeafListStatement> {
private final @NonNull Object substatements;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final @NonNull TypeDefinition<?> type;
private final int flags;
- AbstractLeafListEffectiveStatement(final LeafListStatement declared, final SchemaPath path, final int flags,
+ AbstractLeafListEffectiveStatement(final LeafListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
+ this.path = requireNonNull(path);
this.substatements = maskList(substatements);
- this.path = path;
this.flags = flags;
// TODO: lazy instantiation?
this.type = buildType();
}
- AbstractLeafListEffectiveStatement(final AbstractLeafListEffectiveStatement original, final SchemaPath path,
+ AbstractLeafListEffectiveStatement(final AbstractLeafListEffectiveStatement original, final Object path,
final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.substatements = original.substatements;
- this.path = path;
this.flags = flags;
// FIXME: share with original?
this.type = buildType();
}
@Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-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.LeafListStatement;
private final @Nullable LeafListSchemaNode original;
private final @Nullable ElementCountConstraint elementCountConstraint;
- AbstractNonEmptyLeafListEffectiveStatement(final LeafListStatement declared, final SchemaPath path, final int flags,
+ AbstractNonEmptyLeafListEffectiveStatement(final LeafListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final LeafListSchemaNode original, final ElementCountConstraint elementCountConstraint) {
super(declared, path, flags, substatements);
}
AbstractNonEmptyLeafListEffectiveStatement(final AbstractNonEmptyLeafListEffectiveStatement originalEffecive,
- final LeafListSchemaNode original, final SchemaPath path, final int flags) {
+ final LeafListSchemaNode original, final Object path, final int flags) {
super(originalEffecive, path, flags);
this.elementCountConstraint = originalEffecive.elementCountConstraint;
this.original = original;
}
AbstractNonEmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final SchemaPath path, final int flags) {
+ final LeafListSchemaNode original, final Object path, final int flags) {
super(originalEffective, path, flags);
this.elementCountConstraint = null;
this.original = original;
import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
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.LeafListStatement;
final class EmptyLeafListEffectiveStatement extends AbstractLeafListEffectiveStatement {
- EmptyLeafListEffectiveStatement(final LeafListStatement declared, final SchemaPath path, final int flags,
+ EmptyLeafListEffectiveStatement(final LeafListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, path, flags, substatements);
}
- EmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement original, final SchemaPath path,
+ EmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement original, final Object path,
final int flags) {
super(original, path, flags);
}
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.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
final int flags = computeFlags(stmt, original.effectiveSubstatements());
if (original instanceof RegularLeafListEffectiveStatement) {
return new RegularLeafListEffectiveStatement((RegularLeafListEffectiveStatement) original,
- (LeafListSchemaNode) stmt.original(), stmt.wrapSchemaPath(), flags);
+ (LeafListSchemaNode) stmt.original(), stmt.effectivePath(), flags);
} else if (original instanceof SlimLeafListEffectiveStatement) {
return new SlimLeafListEffectiveStatement((SlimLeafListEffectiveStatement) original,
- (LeafListSchemaNode) stmt.original(), stmt.wrapSchemaPath(), flags);
+ (LeafListSchemaNode) stmt.original(), stmt.effectivePath(), flags);
} else if (original instanceof EmptyLeafListEffectiveStatement) {
// Promote to slim
return new SlimLeafListEffectiveStatement((EmptyLeafListEffectiveStatement) original,
- (LeafListSchemaNode) stmt.original(), stmt.wrapSchemaPath(), flags);
+ (LeafListSchemaNode) stmt.original(), stmt.effectivePath(), flags);
} else {
// Safe fallback
return super.copyEffective(stmt, original);
final LeafListSchemaNode original = (LeafListSchemaNode) stmt.original();
final LeafListStatement declared = stmt.declared();
- final SchemaPath path = stmt.wrapSchemaPath();
if (defaultValues.isEmpty()) {
return original == null && !elementCountConstraint.isPresent()
- ? new EmptyLeafListEffectiveStatement(declared, path, flags, substatements)
- : new SlimLeafListEffectiveStatement(declared, path, flags, substatements, original,
+ ? new EmptyLeafListEffectiveStatement(declared, stmt.effectivePath(), flags, substatements)
+ : new SlimLeafListEffectiveStatement(declared, stmt.effectivePath(), flags, substatements, original,
elementCountConstraint.orElse(null));
}
- return new RegularLeafListEffectiveStatement(declared, path, flags, substatements, original, defaultValues,
- elementCountConstraint.orElse(null));
+ return new RegularLeafListEffectiveStatement(declared, stmt.effectivePath(), flags, substatements, original,
+ defaultValues, elementCountConstraint.orElse(null));
}
private static int computeFlags(final Current<?, ?> stmt,
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-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.LeafListStatement;
final class RegularLeafListEffectiveStatement extends AbstractNonEmptyLeafListEffectiveStatement {
private final @NonNull ImmutableSet<String> defaults;
- RegularLeafListEffectiveStatement(final LeafListStatement declared, final SchemaPath path, final int flags,
+ RegularLeafListEffectiveStatement(final LeafListStatement declared, final Object path, 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);
}
RegularLeafListEffectiveStatement(final RegularLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final SchemaPath path, final int flags) {
+ final LeafListSchemaNode original, final Object path, final int flags) {
super(originalEffective, original, path, flags);
this.defaults = originalEffective.defaults;
}
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-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.LeafListStatement;
final class SlimLeafListEffectiveStatement extends AbstractNonEmptyLeafListEffectiveStatement {
- SlimLeafListEffectiveStatement(final LeafListStatement declared, final SchemaPath path, final int flags,
+ SlimLeafListEffectiveStatement(final LeafListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final LeafListSchemaNode original, final ElementCountConstraint elementCountConstraint) {
super(declared, path, flags, substatements, original, elementCountConstraint);
}
SlimLeafListEffectiveStatement(final SlimLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final SchemaPath path, final int flags) {
+ final LeafListSchemaNode original, final Object path, final int flags) {
super(originalEffective, original, path, flags);
}
SlimLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
- final LeafListSchemaNode original, final SchemaPath path, final int flags) {
+ final LeafListSchemaNode original, final Object path, final int flags) {
super(originalEffective, original, path, flags);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-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.stmt.ListEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
ActionNodeContainerMixin<QName, ListStatement>, MustConstraintMixin<QName, ListStatement> {
private final int flags;
private final @NonNull Object substatements;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final @NonNull Object keyDefinition;
- AbstractListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
+ AbstractListEffectiveStatement(final ListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition) {
super(declared, substatements);
-
+ this.path = requireNonNull(path);
this.substatements = maskList(substatements);
- this.path = path;
this.keyDefinition = maskList(keyDefinition);
this.flags = flags;
}
- AbstractListEffectiveStatement(final AbstractListEffectiveStatement original, final SchemaPath path,
- final int flags) {
+ AbstractListEffectiveStatement(final AbstractListEffectiveStatement original, final Object path, final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.substatements = original.substatements;
this.keyDefinition = original.keyDefinition;
- this.path = path;
this.flags = flags;
}
}
@Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public final Object pathObject() {
+ return path;
}
@Override
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.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
final class EmptyListEffectiveStatement extends AbstractListEffectiveStatement {
- EmptyListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
+ EmptyListEffectiveStatement(final ListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition) {
super(declared, path, flags, substatements, keyDefinition);
}
- EmptyListEffectiveStatement(final EmptyListEffectiveStatement original, final SchemaPath path, final int flags) {
+ EmptyListEffectiveStatement(final EmptyListEffectiveStatement original, final Object path, final int flags) {
super(original, path, flags);
}
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
final int flags = computeFlags(stmt, original.effectiveSubstatements());
if (original instanceof RegularListEffectiveStatement) {
return new RegularListEffectiveStatement((RegularListEffectiveStatement) original,
- (ListSchemaNode) stmt.original(), stmt.wrapSchemaPath(), flags);
+ (ListSchemaNode) stmt.original(), stmt.effectivePath(), flags);
} else if (original instanceof EmptyListEffectiveStatement) {
return new RegularListEffectiveStatement((EmptyListEffectiveStatement) original,
- (ListSchemaNode) stmt.original(), stmt.wrapSchemaPath(), flags);
+ (ListSchemaNode) stmt.original(), stmt.effectivePath(), flags);
} else {
// Safe fallback
return super.copyEffective(stmt, original);
final Optional<ElementCountConstraint> elementCountConstraint =
EffectiveStmtUtils.createElementCountConstraint(substatements);
- final SchemaPath path = stmt.wrapSchemaPath();
+ final Object path = stmt.effectivePath();
final ListSchemaNode original = (ListSchemaNode) stmt.original();
try {
return original == null && !elementCountConstraint.isPresent()
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
private final ElementCountConstraint elementCountConstraint;
private final ListSchemaNode original;
- RegularListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
+ RegularListEffectiveStatement(final ListStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition, final ElementCountConstraint elementCountConstraint,
final ListSchemaNode original) {
}
RegularListEffectiveStatement(final RegularListEffectiveStatement originalEffective, final ListSchemaNode original,
- final SchemaPath path, final int flags) {
+ final Object path, final int flags) {
super(originalEffective, path, flags);
this.elementCountConstraint = originalEffective.elementCountConstraint;
this.original = original;
}
RegularListEffectiveStatement(final EmptyListEffectiveStatement originalEffective, final ListSchemaNode original,
- final SchemaPath path, final int flags) {
+ final Object path, final int flags) {
super(originalEffective, path, flags);
this.elementCountConstraint = null;
this.original = original;
protected final NotificationEffectiveStatement createEffective(final Current<QName, NotificationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new NotificationEffectiveStatementImpl(stmt.declared(), substatements,
- EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements), stmt.wrapSchemaPath());
+ return new NotificationEffectiveStatementImpl(stmt.declared(), substatements, stmt.effectivePath(),
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
public final NotificationEffectiveStatement copyEffective(final Current<QName, NotificationStatement> stmt,
final NotificationEffectiveStatement original) {
return new NotificationEffectiveStatementImpl((NotificationEffectiveStatementImpl) original,
- EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()),
- stmt.wrapSchemaPath());
+ stmt.effectivePath(),
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()));
}
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-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.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
AugmentationTargetMixin<QName, NotificationStatement>, CopyableMixin<QName, NotificationStatement>,
MustConstraintMixin<QName, NotificationStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
NotificationEffectiveStatementImpl(final NotificationStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final SchemaPath path) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags) {
super(declared, substatements);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
- NotificationEffectiveStatementImpl(final NotificationEffectiveStatementImpl original, final int flags,
- final SchemaPath path) {
+ NotificationEffectiveStatementImpl(final NotificationEffectiveStatementImpl original, final Object path,
+ final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
@Override
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
-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.stmt.OutputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
final class DeclaredOutputEffectiveStatement extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
- DeclaredOutputEffectiveStatement(final int flags, final OutputStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
+ DeclaredOutputEffectiveStatement(final OutputStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags) {
super(declared, substatements);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
- DeclaredOutputEffectiveStatement(final int flags, final DeclaredOutputEffectiveStatement original,
- final SchemaPath path) {
+ DeclaredOutputEffectiveStatement(final DeclaredOutputEffectiveStatement original, final Object path,
+ final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
@Override
protected OutputEffectiveStatement copyDeclaredEffective(final int flags,
final Current<QName, OutputStatement> stmt, final OutputEffectiveStatement original) {
- return new DeclaredOutputEffectiveStatement(flags, (DeclaredOutputEffectiveStatement) original,
- stmt.wrapSchemaPath());
+ return new DeclaredOutputEffectiveStatement((DeclaredOutputEffectiveStatement) original, stmt.effectivePath(),
+ flags);
}
@Override
protected OutputEffectiveStatement copyUndeclaredEffective(final int flags,
final Current<QName, OutputStatement> stmt, final OutputEffectiveStatement original) {
- return new UndeclaredOutputEffectiveStatement(flags, (UndeclaredOutputEffectiveStatement) original,
- stmt.wrapSchemaPath());
+ return new UndeclaredOutputEffectiveStatement((UndeclaredOutputEffectiveStatement) original,
+ stmt.effectivePath(), flags);
}
@Override
protected OutputEffectiveStatement createDeclaredEffective(final int flags,
final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DeclaredOutputEffectiveStatement(flags, stmt.declared(), substatements, stmt.wrapSchemaPath());
+ return new DeclaredOutputEffectiveStatement(stmt.declared(), substatements, stmt.effectivePath(), flags);
}
@Override
final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new UndeclaredOutputEffectiveStatement(flags, substatements, stmt.wrapSchemaPath());
+ return new UndeclaredOutputEffectiveStatement(substatements, stmt.effectivePath(), flags);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
-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.stmt.OutputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
final class UndeclaredOutputEffectiveStatement
extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
- UndeclaredOutputEffectiveStatement(final int flags,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
+ UndeclaredOutputEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final Object path, final int flags) {
super(substatements);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
- UndeclaredOutputEffectiveStatement(final int flags, final UndeclaredOutputEffectiveStatement original,
- final SchemaPath path) {
+ UndeclaredOutputEffectiveStatement(final UndeclaredOutputEffectiveStatement original, final Object path,
+ final int flags) {
super(original);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = path;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
protected RefineEffectiveStatement createEffective(final Current<Descendant, RefineStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
// Empty refine is exceedingly unlikely: let's be lazy and reuse the implementation
- return new RefineEffectiveStatementImpl(stmt.declared(), substatements, stmt.wrapSchemaPath(),
+ return new RefineEffectiveStatementImpl(stmt.declared(), substatements, stmt.optionalPath(),
(SchemaNode) verifyNotNull(stmt.namespaceItem(RefineTargetNamespace.class, Empty.getInstance()))
.buildEffective());
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-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.stmt.RpcEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
final class RpcEffectiveStatementImpl extends WithSubstatements<QName, RpcStatement, RpcEffectiveStatement>
implements RpcDefinition, RpcEffectiveStatement, OperationDefinitionMixin<RpcStatement> {
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
RpcEffectiveStatementImpl(final RpcStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags, final SchemaPath path) {
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final Object path, final int flags) {
super(declared, substatements);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
checkState(!substatements.isEmpty(), "Missing implicit input/output statements at %s", stmt.sourceReference());
try {
- return new RpcEffectiveStatementImpl(stmt.declared(), substatements, computeFlags(substatements),
- stmt.wrapSchemaPath());
+ return new RpcEffectiveStatementImpl(stmt.declared(), substatements, stmt.effectivePath(),
+ computeFlags(substatements));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef;
+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.eclipse.jdt.annotation.Nullable;
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.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
private final @NonNull Object substatements;
- private final @Nullable SchemaPath path;
+ private final @NonNull Object path;
private final int flags;
// Accessed via TYPE_DEFINITION
@SuppressWarnings("unused")
private volatile ProxyTypeEffectiveStatement typeStatement;
- TypedefEffectiveStatementImpl(final TypedefStatement declared, final SchemaPath path, final int flags,
+ TypedefEffectiveStatementImpl(final TypedefStatement declared, final Object path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
- this.path = path;
+ this.path = requireNonNull(path);
this.flags = flags;
this.substatements = maskList(substatements);
}
}
@Override
- @Deprecated
- public SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ public Object pathObject() {
+ return path;
}
@Override
EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeEffectiveStmt, dflt), stmt,
"Typedef '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- return new TypedefEffectiveStatementImpl(declared, stmt.wrapSchemaPath(), computeFlags(substatements),
+ return new TypedefEffectiveStatementImpl(declared, stmt.effectivePath(), computeFlags(substatements),
substatements);
}
ThirdPartyExtensionEffectiveStatementImpl(final Current<String, ThirdPartyExtensionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
+ path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
valueFromNamespace = stmt.getFromNamespace(ThirdPartyNamespace.class, Empty.getInstance());
}
// FIXME: 7.0.0: this is currently only used by AbstractTypeStatement
@NonNull QNameModule effectiveNamespace();
+ default @NonNull Object effectivePath() {
+ return SchemaPathSupport.toEffectivePath(getSchemaPath());
+ }
+
+ default @Nullable SchemaPath optionalPath() {
+ return SchemaPathSupport.toOptionalPath(getSchemaPath());
+ }
+
/**
* Return the {@link SchemaPath} of this statement. Not all statements have a SchemaPath, in which case
* {@link Optional#empty()} is returned.
default @NonNull SchemaPath getSchemaPath() {
return schemaPath().orElseThrow();
}
-
- @Deprecated
- default @Nullable SchemaPath wrapSchemaPath() {
- return SchemaPathSupport.wrap(getSchemaPath());
- }
}
/**
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
+import static com.google.common.base.Verify.verifyNotNull;
+
import com.google.common.annotations.Beta;
+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.SchemaNodeDefaults;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@Beta
-@Deprecated
+// FIXME: remove this class once we ditch SchemaPath.getPath()
public abstract class SchemaPathSupport implements Immutable {
private static final class Enabled extends SchemaPathSupport {
@Override
- SchemaPath nullableWrap(final SchemaPath path) {
+ SchemaPath effectivePath(final SchemaPath path) {
+ return path;
+ }
+
+ @Override
+ SchemaPath optionalPath(final SchemaPath path) {
return path;
}
}
- public static final SchemaPathSupport DEFAULT = new Enabled();
+ private static final SchemaPathSupport DEFAULT = new Enabled();
private SchemaPathSupport() {
// Hidden on purpose
}
- public static @Nullable SchemaPath wrap(final @Nullable SchemaPath path) {
- return DEFAULT.nullableWrap(path);
+ public static @NonNull Object toEffectivePath(final @NonNull SchemaPath path) {
+ return DEFAULT.effectivePath(path);
+ }
+
+ public static @Nullable SchemaPath toOptionalPath(final @Nullable SchemaPath path) {
+ return DEFAULT.optionalPath(path);
+ }
+
+ public static @NonNull QName extractQName(final @NonNull Object path) {
+ return path instanceof QName ? (QName) path : verifyNotNull(((SchemaPath) path).getLastComponent());
}
- abstract @Nullable SchemaPath nullableWrap(@Nullable SchemaPath path);
+ public static @NonNull SchemaPath extractPath(final @NonNull Object impl, final @NonNull Object path) {
+ return path instanceof SchemaPath ? (SchemaPath) path : SchemaNodeDefaults.throwUnsupported(impl);
+ }
+
+ abstract @NonNull Object effectivePath(@NonNull SchemaPath path);
+
+ abstract @Nullable SchemaPath optionalPath(@Nullable SchemaPath path);
}
Code Review / yangtools.git / commitdiff