import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.odlext.model.api.AnyxmlSchemaLocationEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.AnyxmlSchemaLocationStatement;
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.stmt.SchemaNodeIdentifier;
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;
@VisibleForTesting
public final class AnyxmlSchemaLocationEffectiveStatementImpl
extends UnknownEffectiveStatementBase<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement>
implements AnyxmlSchemaLocationEffectiveStatement {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
AnyxmlSchemaLocationEffectiveStatementImpl(
final Current<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
}
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;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
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.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
definition = stmt.publicDefinition();
- path = stmt.getEffectiveParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ .createChild(stmt.publicDefinition().getStatementName()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(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;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
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.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
private static final class Effective
extends UnknownEffectiveStatementBase<Void, GetFilterElementAttributesStatement>
implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
Effective(final Current<Void, GetFilterElementAttributesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ .createChild(stmt.publicDefinition().getStatementName()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(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;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
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.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
private static final class Effective extends UnknownEffectiveStatementBase<Void, DefaultDenyAllStatement>
implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
Effective(final Current<Void, DefaultDenyAllStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ .createChild(stmt.publicDefinition().getStatementName()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(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;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
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.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
private static final class Effective extends UnknownEffectiveStatementBase<Void, DefaultDenyWriteStatement>
implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
Effective(final Current<Void, DefaultDenyWriteStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath()
+ .createChild(stmt.publicDefinition().getStatementName()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@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 {
AliasEffectiveStatementImpl(final Current<String, AliasStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
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 {
DefValEffectiveStatementImpl(final Current<String, DefValStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
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 {
DisplayHintEffectiveStatementImpl(final Current<String, DisplayHintStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
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 {
ImpliedEffectiveStatementImpl(final Current<String, ImpliedStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
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 {
MaxAccessEffectiveStatementImpl(final Current<MaxAccess, MaxAccessStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
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 {
OidEffectiveStatementImpl(final Current<ObjectIdentifier, OidStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
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 {
SubIdEffectiveStatementImpl(final Current<Uint32, SubIdStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(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.rfc7952.model.api.AnnotationEffectiveStatement;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationStatement;
import org.opendaylight.yangtools.rfc7952.model.api.MetadataStatements;
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.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
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.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
implements AnnotationEffectiveStatement, AnnotationSchemaNode {
private final @NonNull TypeDefinition<?> type;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
Effective(final Current<QName, AnnotationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(argument());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(argument()));
final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull(
firstSubstatementOfType(TypeEffectiveStatement.class), stmt,
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
import com.google.common.base.Verify;
import com.google.common.collect.ImmutableList;
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.stmt.ContainerEffectiveStatement;
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.meta.StmtContextUtils;
@Beta
final class YangDataEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, YangDataStatement>
implements YangDataEffectiveStatement, YangDataSchemaNode {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final @NonNull QName maybeQNameArgument;
private final @NonNull ContainerEffectiveStatement container;
}
this.maybeQNameArgument = maybeQNameArgumentInit;
- path = stmt.getEffectiveParent().getSchemaPath().createChild(maybeQNameArgument);
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(maybeQNameArgument));
container = findFirstEffectiveSubstatement(ContainerEffectiveStatement.class).get();
// TODO: this is strong binding of two API contracts. Unfortunately ContainerEffectiveStatement design is
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(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.rfc8528.model.api.MountPointEffectiveStatement;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointSchemaNode;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointStatement;
import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountStatements;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+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;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
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.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
private static final class Effective extends UnknownEffectiveStatementBase<QName, MountPointStatement>
implements MountPointEffectiveStatement, MountPointSchemaNode {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
Effective(final Current<QName, MountPointStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(argument());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(argument()));
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.collect.ImmutableList;
import java.util.Collection;
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;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractTypeDefinition<T extends TypeDefinition<T>> implements Immutable, TypeDefinition<T> {
private final @NonNull ImmutableList<UnknownSchemaNode> unknownSchemaNodes;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
AbstractTypeDefinition(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- this.path = requireNonNull(path);
+ this.path = path;
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
}
public static @NonNull DerivedTypeBuilder<?> derivedTypeBuilder(final @NonNull TypeDefinition<?> baseType,
- final @NonNull SchemaPath path) {
+ final @Nullable SchemaPath path) {
if (baseType instanceof BinaryTypeDefinition) {
return derivedBinaryBuilder((BinaryTypeDefinition) baseType, path);
} else if (baseType instanceof BitsTypeDefinition) {
}
public static @NonNull DerivedTypeBuilder<BinaryTypeDefinition> derivedBinaryBuilder(
- final @NonNull BinaryTypeDefinition baseType, final @NonNull SchemaPath path) {
+ final @NonNull BinaryTypeDefinition baseType, final @Nullable SchemaPath path) {
return new DerivedTypeBuilder<BinaryTypeDefinition>(baseType, path) {
@Override
public BinaryTypeDefinition build() {
}
public static @NonNull DerivedTypeBuilder<BooleanTypeDefinition> derivedBooleanBuilder(
- final @NonNull BooleanTypeDefinition baseType, final @NonNull SchemaPath path) {
+ final @NonNull BooleanTypeDefinition baseType, final @Nullable SchemaPath path) {
return new DerivedTypeBuilder<BooleanTypeDefinition>(baseType, path) {
@Override
public BooleanTypeDefinition build() {
}
public static @NonNull LengthRestrictedTypeBuilder<BinaryTypeDefinition> newBinaryBuilder(
- final @NonNull BinaryTypeDefinition baseType, final @NonNull SchemaPath path) {
+ final @NonNull BinaryTypeDefinition baseType, final @Nullable SchemaPath path) {
return new LengthRestrictedTypeBuilder<>(baseType, path) {
@Override
BinaryTypeDefinition buildType(final @Nullable LengthConstraint constraint) {
}
public static @NonNull TypeBuilder<BooleanTypeDefinition> newBooleanBuilder(
- final @NonNull BooleanTypeDefinition baseType, final @NonNull SchemaPath path) {
+ final @NonNull BooleanTypeDefinition baseType, final @Nullable SchemaPath path) {
return new AbstractRestrictedTypeBuilder<>(baseType, path) {
@Override
BooleanTypeDefinition buildType() {
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Builder;
+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;
public abstract class TypeBuilder<T extends TypeDefinition<T>> implements Builder<T> {
private final ImmutableList.Builder<UnknownSchemaNode> unknownSchemaNodes = ImmutableList.builder();
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final T baseType;
TypeBuilder(final T baseType, final SchemaPath path) {
- this.path = requireNonNull(path);
+ this.path = path;
this.baseType = baseType;
}
return baseType;
}
- final @NonNull SchemaPath getPath() {
- return path;
+ final @Nullable SchemaPath getPath() {
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
final @NonNull Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
protected final IdentityEffectiveStatement createEffective(final Current<QName, IdentityStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
if (substatements.isEmpty()) {
- return new EmptyIdentityEffectiveStatement(stmt.declared(), stmt.getSchemaPath());
+ return new EmptyIdentityEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath());
}
final List<IdentitySchemaNode> identities = new ArrayList<>();
}
}
- return new RegularIdentityEffectiveStatement(stmt.declared(), stmt.getSchemaPath(), new FlagsBuilder()
+ return new RegularIdentityEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath(), new FlagsBuilder()
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags(), substatements, ImmutableSet.copyOf(identities));
}
throw noBase(stmt);
}
- final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(stmt.getSchemaPath());
+ final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(stmt.wrapSchemaPath());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof BaseEffectiveStatement) {
final QName identityQName = ((BaseEffectiveStatement) subStmt).argument();
throw noPath(stmt);
}
- final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(stmt.getSchemaPath());
+ final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(stmt.wrapSchemaPath());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof PathEffectiveStatement) {
}
static final SchemaPath typeEffectiveSchemaPath(final Current<?, ?> stmt) {
- final SchemaPath path = stmt.getSchemaPath();
+ final SchemaPath path = stmt.wrapSchemaPath();
+ if (path == null) {
+ // SchemaPath is forbidden with a system property
+ return null;
+ }
final SchemaPath parent = path.getParent();
final QName parentQName = parent.getLastComponent();
checkArgument(parentQName != null, "Path %s has an empty parent", path);
private @NonNull TypeEffectiveStatement<TypeStatement> createBits(final Current<?, ?> ctx,
final BitsTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.getSchemaPath());
+ final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.wrapSchemaPath());
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof BitEffectiveStatement) {
private @NonNull TypeEffectiveStatement<TypeStatement> createEnum(final Current<?, ?> ctx,
final EnumTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, ctx.getSchemaPath());
+ final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, ctx.wrapSchemaPath());
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof EnumEffectiveStatement) {
throw noBits(stmt);
}
- final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(stmt.getSchemaPath());
+ final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(stmt.wrapSchemaPath());
Uint32 highestPosition = null;
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof BitEffectiveStatement) {
throw noFracDigits(stmt);
}
- final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(stmt.getSchemaPath());
+ final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(stmt.wrapSchemaPath());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof FractionDigitsEffectiveStatement) {
builder.setFractionDigits(((FractionDigitsEffectiveStatement) subStmt).argument());
throw noEnum(stmt);
}
- final EnumerationTypeBuilder builder = BaseTypes.enumerationTypeBuilder(stmt.getSchemaPath());
+ final EnumerationTypeBuilder builder = BaseTypes.enumerationTypeBuilder(stmt.wrapSchemaPath());
Integer highestValue = null;
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof EnumEffectiveStatement) {
final Current<String, InstanceIdentifierSpecification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(
- BaseTypes.instanceIdentifierType(), stmt.getSchemaPath());
+ BaseTypes.instanceIdentifierType(), stmt.wrapSchemaPath());
// TODO: we could do better here for empty substatements, but its really splitting hairs
for (EffectiveStatement<?, ?> subStmt : substatements) {
throw noType(stmt);
}
- final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(stmt.getSchemaPath());
+ final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(stmt.wrapSchemaPath());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof TypeEffectiveStatement) {