package org.opendaylight.yangtools.yang.parser.openconfig.stmt;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionEffectiveStatement;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionStatement;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class OpenConfigVersionEffectiveStatementImpl
extends UnknownEffectiveStatementBase<SemVer, OpenConfigVersionStatement>
implements OpenConfigVersionEffectiveStatement {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
OpenConfigVersionEffectiveStatementImpl(final Current<SemVer, OpenConfigVersionStatement> 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);
}
}
*/
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.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
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;
final class ActionEffectiveStatementImpl extends WithSubstatements<QName, ActionStatement, ActionEffectiveStatement>
implements ActionDefinition, ActionEffectiveStatement, OperationDefinitionMixin<ActionStatement>,
CopyableMixin<QName, ActionStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
ActionEffectiveStatementImpl(final ActionStatement declared, final SchemaPath path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
"Action %s is defined at the top level of a module", argument);
try {
- return new ActionEffectiveStatementImpl(stmt.declared(), stmt.getSchemaPath(),
+ return new ActionEffectiveStatementImpl(stmt.declared(), stmt.wrapSchemaPath(),
historyAndStatusFlags(stmt.history(), substatements), substatements);
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
protected AnydataEffectiveStatement createEffective(final Current<QName, AnydataStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final int flags = computeFlags(stmt.history(), stmt.effectiveConfig(), substatements);
- final SchemaPath path = stmt.getSchemaPath();
+ final SchemaPath path = stmt.wrapSchemaPath();
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;
class EmptyAnydataEffectiveStatement extends Default<QName, AnydataStatement>
implements AnydataEffectiveStatement, AnydataSchemaNode, OpaqueDataSchemaNodeMixin<AnydataStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final AnydataSchemaNode original;
private final int flags;
EmptyAnydataEffectiveStatement(final AnydataStatement declared, final SchemaPath path, final int flags,
final @Nullable AnydataSchemaNode original) {
super(declared);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
this.original = original;
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
protected AnyxmlEffectiveStatement createEffective(final Current<QName, AnyxmlStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final int flags = computeFlags(stmt.history(), stmt.effectiveConfig(), substatements);
- final SchemaPath path = stmt.getSchemaPath();
+ final SchemaPath path = stmt.wrapSchemaPath();
return substatements.isEmpty()
? new EmptyAnyxmlEffectiveStatement(stmt.declared(), path, flags, findOriginal(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;
class EmptyAnyxmlEffectiveStatement extends Default<QName, AnyxmlStatement>
implements AnyxmlEffectiveStatement, AnyxmlSchemaNode, OpaqueDataSchemaNodeMixin<AnyxmlStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final AnyxmlSchemaNode original;
private final int flags;
EmptyAnyxmlEffectiveStatement(final AnyxmlStatement declared, final SchemaPath path, final int flags,
final @Nullable AnyxmlSchemaNode original) {
super(declared);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
this.original = original;
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
return new DeclaredCaseEffectiveStatement(stmt.declared(), substatements, computeFlags(stmt, substatements),
- stmt.getSchemaPath(), findOriginal(stmt));
+ stmt.wrapSchemaPath(), findOriginal(stmt));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
}
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
return new UndeclaredCaseEffectiveStatement(substatements, computeFlags(stmt, substatements),
- stmt.getSchemaPath(), findOriginal(stmt));
+ stmt.wrapSchemaPath(), findOriginal(stmt));
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), 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;
final class DeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
private final CaseSchemaNode original;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
DeclaredCaseEffectiveStatement(final CaseStatement declared,
final SchemaPath path, final @Nullable CaseSchemaNode original) {
super(declared, substatements);
this.flags = flags;
- this.path = requireNonNull(path);
+ this.path = path;
this.original = original;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, 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;
final class UndeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
- private final CaseSchemaNode original;
- private final @NonNull SchemaPath path;
+ private final @Nullable CaseSchemaNode original;
+ private final @Nullable SchemaPath path;
private final int flags;
UndeclaredCaseEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final int flags, final SchemaPath path, final @Nullable CaseSchemaNode original) {
super(substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
this.original = original;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
try {
- return new ChoiceEffectiveStatementImpl(stmt.declared(), substatements, flags, stmt.getSchemaPath(),
+ return new ChoiceEffectiveStatementImpl(stmt.declared(), substatements, flags, stmt.wrapSchemaPath(),
defaultCase, (ChoiceSchemaNode) stmt.original());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
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;
MandatoryMixin<QName, ChoiceStatement> {
private final CaseSchemaNode defaultCase;
private final ChoiceSchemaNode original;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
ChoiceEffectiveStatementImpl(final ChoiceStatement declared,
final SchemaPath path, final @Nullable CaseSchemaNode defaultCase,
final @Nullable ChoiceSchemaNode original) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
this.defaultCase = defaultCase;
this.original = original;
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
@Override
protected ContainerEffectiveStatement createEffective(final Current<QName, ContainerStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final SchemaPath path = stmt.getSchemaPath();
final ContainerSchemaNode original = (ContainerSchemaNode) stmt.original();
final int flags = new FlagsBuilder()
.setHistory(stmt.history())
EffectiveStmtUtils.checkUniqueTypedefs(stmt, substatements);
EffectiveStmtUtils.checkUniqueUses(stmt, substatements);
+ final SchemaPath path = stmt.wrapSchemaPath();
try {
return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, flags, path, original);
} catch (SubstatementIndexingException 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;
AugmentationTargetMixin<QName, ContainerStatement> {
private final int flags;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final @Nullable ContainerSchemaNode original;
ContainerEffectiveStatementImpl(final ContainerStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
final SchemaPath path, final ContainerSchemaNode original) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.original = original;
this.flags = flags;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
import java.util.ArrayDeque;
import java.util.Deque;
-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.ExtensionDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
private static final RecursionDetector TOSTRING_DETECTOR = new RecursionDetector();
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private volatile Object substatements;
ExtensionEffectiveStatementImpl(final ExtensionStatement declared, final SchemaPath path) {
super(declared);
- this.path = requireNonNull(path);
+ this.path = path;
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
public boolean isYinElement() {
return findFirstEffectiveSubstatement(ArgumentEffectiveStatement.class)
.flatMap(arg -> arg.findFirstEffectiveSubstatementArgument(YinElementEffectiveStatement.class))
- .orElse(Boolean.FALSE)
- .booleanValue();
+ .orElse(Boolean.FALSE);
}
@Override
try {
final ExtensionEffectiveStatementImpl created = new ExtensionEffectiveStatementImpl(stmt.declared(),
- stmt.getSchemaPath());
+ stmt.wrapSchemaPath());
verify(tl.put(stmt, created) == null);
try {
return super.createEffective(stmt, declaredSubstatements, effectiveSubstatements);
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.AbstractQName;
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.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
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;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(UnrecognizedEffectiveStatementImpl.class);
private final QName maybeQNameArgument;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
UnrecognizedEffectiveStatementImpl(final Current<String, UnrecognizedStatement> stmt,
final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
LOG.debug("Cannot construct path for {}, attempting to recover", stmt, e);
maybePath = null;
}
- path = maybePath;
+ path = SchemaPathSupport.wrap(maybePath);
}
@Override
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@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;
class EmptyFeatureEffectiveStatement extends Default<QName, FeatureStatement>
implements FeatureDefinition, FeatureEffectiveStatement, SchemaNodeMixin<QName, FeatureStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
EmptyFeatureEffectiveStatement(final FeatureStatement declared, final SchemaPath path, final int flags) {
super(declared);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
protected FeatureEffectiveStatement createEffective(final Current<QName, FeatureStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return substatements.isEmpty()
- ? new EmptyFeatureEffectiveStatement(stmt.declared(), stmt.getSchemaPath(), EMPTY_EFFECTIVE_FLAGS)
- : new RegularFeatureEffectiveStatement(stmt.declared(), stmt.getSchemaPath(),
+ ? new EmptyFeatureEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath(), EMPTY_EFFECTIVE_FLAGS)
+ : new RegularFeatureEffectiveStatement(stmt.declared(), stmt.wrapSchemaPath(),
computeFlags(substatements), substatements);
}
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
return new GroupingEffectiveStatementImpl(stmt.declared(), substatements,
- historyAndStatusFlags(stmt.history(), substatements), stmt.getSchemaPath());
+ historyAndStatusFlags(stmt.history(), substatements), stmt.wrapSchemaPath());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
-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.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;
DataNodeContainerMixin<QName, GroupingStatement>,
SchemaNodeMixin<QName, GroupingStatement>, ActionNodeContainerMixin<QName, GroupingStatement>,
NotificationNodeContainerMixin<QName, GroupingStatement>, AddedByUsesMixin<QName, GroupingStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
GroupingEffectiveStatementImpl(final GroupingStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
final SchemaPath path) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
}
@Override
- public @Nullable QName argument() {
+ public QName argument() {
return getQName();
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
*/
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.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
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;
abstract class AbstractIdentityEffectiveStatement extends DefaultArgument<QName, IdentityStatement>
implements IdentityEffectiveStatement, IdentitySchemaNode, SchemaNodeMixin<QName, IdentityStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
AbstractIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path) {
super(declared);
- this.path = requireNonNull(path);
+ this.path = path;
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
protected final InputEffectiveStatement createDeclaredEffective(final int flags,
final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DeclaredInputEffectiveStatement(flags, stmt.declared(), substatements, stmt.getSchemaPath());
+ return new DeclaredInputEffectiveStatement(flags, stmt.declared(), substatements, stmt.wrapSchemaPath());
}
@Override
final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new UndeclaredInputEffectiveStatement(flags, substatements, stmt.getSchemaPath());
+ return new UndeclaredInputEffectiveStatement(flags, substatements, stmt.wrapSchemaPath());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
-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.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;
final class DeclaredInputEffectiveStatement extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
DeclaredInputEffectiveStatement(final int flags, final InputStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
super(declared, substatements);
this.flags = flags;
- this.path = requireNonNull(path);
+ this.path = path;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
-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.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;
final class UndeclaredInputEffectiveStatement
extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
UndeclaredInputEffectiveStatement(final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
super(substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, 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;
DataSchemaNodeMixin<QName, LeafStatement>, MandatoryMixin<QName, LeafStatement>,
MustConstraintMixin<QName, LeafStatement> {
private final @NonNull Object substatements;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final @NonNull TypeDefinition<?> type;
private final int flags;
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
this.substatements = maskList(substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
// TODO: lazy instantiation?
this.type = buildType();
}
@Override
- public final @NonNull QName argument() {
+ public final QName argument() {
return getQName();
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
stmt.sourceReference(),
"Leaf '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- final SchemaPath path = stmt.getSchemaPath();
final LeafSchemaNode original = (LeafSchemaNode) stmt.original();
final int flags = new FlagsBuilder()
.setHistory(stmt.history())
.toFlags();
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);
}
*/
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;
UserOrderedMixin<QName, LeafListStatement>, DataSchemaNodeMixin<QName, LeafListStatement>,
MustConstraintMixin<QName, LeafListStatement> {
private final @NonNull Object substatements;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final @NonNull TypeDefinition<?> type;
private final int flags;
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
this.substatements = maskList(substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
// TODO: lazy instantiation?
this.type = buildType();
}
@Override
- public final @NonNull QName argument() {
+ public final QName argument() {
return getQName();
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
findFirstStatement(substatements, TypeEffectiveStatement.class), stmt.sourceReference(),
"Leaf-list is missing a 'type' statement");
- final SchemaPath path = stmt.getSchemaPath();
final LeafListSchemaNode original = (LeafListSchemaNode) stmt.original();
final int flags = new FlagsBuilder()
EffectiveStmtUtils.createElementCountConstraint(substatements);
final LeafListStatement declared = stmt.declared();
+ final SchemaPath path = stmt.wrapSchemaPath();
if (defaultValues.isEmpty()) {
return original == null && !elementCountConstraint.isPresent()
? new EmptyLeafListEffectiveStatement(declared, path, flags, substatements)
*/
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 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.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;
ActionNodeContainerMixin<QName, ListStatement>, MustConstraintMixin<QName, ListStatement> {
private final int flags;
private final @NonNull Object substatements;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final @NonNull Object keyDefinition;
AbstractListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
super(declared, substatements);
this.substatements = maskList(substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.keyDefinition = maskList(keyDefinition);
this.flags = flags;
}
}
@Override
- public final @NonNull QName argument() {
+ public final QName argument() {
return getQName();
}
@Override
@Deprecated
public final SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
@Override
protected ListEffectiveStatement createEffective(final Current<QName, ListStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final SchemaPath path = stmt.getSchemaPath();
final ListSchemaNode original = (ListSchemaNode) stmt.original();
final ImmutableList<QName> keyDefinition;
warnConfigList(stmt);
}
- final Optional<ElementCountConstraint> elementCountConstraint =
- EffectiveStmtUtils.createElementCountConstraint(substatements);
-
EffectiveStmtUtils.checkUniqueGroupings(stmt, substatements);
EffectiveStmtUtils.checkUniqueTypedefs(stmt, substatements);
EffectiveStmtUtils.checkUniqueUses(stmt, substatements);
+ final Optional<ElementCountConstraint> elementCountConstraint =
+ EffectiveStmtUtils.createElementCountConstraint(substatements);
+ final SchemaPath path = stmt.wrapSchemaPath();
try {
return original == null && !elementCountConstraint.isPresent()
? new EmptyListEffectiveStatement(stmt.declared(), path, flags, substatements, keyDefinition)
try {
return new NotificationEffectiveStatementImpl(stmt.declared(), substatements,
- historyAndStatusFlags(stmt.history(), substatements), stmt.getSchemaPath());
+ historyAndStatusFlags(stmt.history(), substatements), stmt.wrapSchemaPath());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
-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.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;
AugmentationTargetMixin<QName, NotificationStatement>, CopyableMixin<QName, NotificationStatement>,
MustConstraintMixin<QName, NotificationStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
NotificationEffectiveStatementImpl(final NotificationStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
final SchemaPath path) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
@Override
- public @NonNull QName argument() {
+ public QName argument() {
return getQName();
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
protected final OutputEffectiveStatement createDeclaredEffective(final int flags,
final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DeclaredOutputEffectiveStatement(flags, stmt.declared(), substatements, stmt.getSchemaPath());
+ return new DeclaredOutputEffectiveStatement(flags, stmt.declared(), substatements, stmt.wrapSchemaPath());
}
@Override
final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
try {
- return new UndeclaredOutputEffectiveStatement(flags, substatements, stmt.getSchemaPath());
+ return new UndeclaredOutputEffectiveStatement(flags, substatements, stmt.wrapSchemaPath());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
-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.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;
final class DeclaredOutputEffectiveStatement extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
DeclaredOutputEffectiveStatement(final int flags, final OutputStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
super(declared, substatements);
this.flags = flags;
- this.path = requireNonNull(path);
+ this.path = path;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
-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.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;
final class UndeclaredOutputEffectiveStatement
extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
UndeclaredOutputEffectiveStatement(final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
super(substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
protected final 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.getSchemaPath(),
+ return new RefineEffectiveStatementImpl(stmt.declared(), substatements, stmt.wrapSchemaPath(),
(SchemaNode) stmt.caerbannog().getEffectOfStatement().iterator().next().buildEffective());
}
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
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.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
// FIXME: 7.0.0: do not implement SchemaNode
public final class RefineEffectiveStatementImpl extends WithSubstatements<Descendant, RefineStatement>
implements RefineEffectiveStatement, SchemaNode, DocumentedNodeMixin<Descendant, RefineStatement> {
- private final @NonNull SchemaPath path;
- private final SchemaNode refineTargetNode;
+ private final @NonNull SchemaNode refineTargetNode;
+ private final @Nullable SchemaPath path;
RefineEffectiveStatementImpl(final RefineStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path,
final SchemaNode refineTargetNode) {
super(declared, substatements);
- this.path = requireNonNull(path);
this.refineTargetNode = requireNonNull(refineTargetNode);
+ this.path = path;
}
public SchemaNode getRefineTargetNode() {
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
try {
return new RpcEffectiveStatementImpl(stmt.declared(), substatements, computeFlags(substatements),
- stmt.getSchemaPath());
+ stmt.wrapSchemaPath());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt.sourceReference(), e);
}
*/
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.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
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;
final class RpcEffectiveStatementImpl extends WithSubstatements<QName, RpcStatement, RpcEffectiveStatement>
implements RpcDefinition, RpcEffectiveStatement, OperationDefinitionMixin<RpcStatement> {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
RpcEffectiveStatementImpl(final RpcStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags, final SchemaPath path) {
super(declared, substatements);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
*/
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;
}
private final @NonNull Object substatements;
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final int flags;
// Accessed via TYPE_DEFINITION
TypedefEffectiveStatementImpl(final TypedefStatement declared, final SchemaPath path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared);
- this.path = requireNonNull(path);
+ this.path = path;
this.flags = flags;
this.substatements = maskList(substatements);
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
@Override
stmt.sourceReference(),
"Typedef '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- return new TypedefEffectiveStatementImpl(declared, stmt.getSchemaPath(), computeFlags(substatements),
+ return new TypedefEffectiveStatementImpl(declared, stmt.wrapSchemaPath(), computeFlags(substatements),
substatements);
}
package org.opendaylight.yangtools.yang.thirdparty.plugin;
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.SchemaNodeDefaults;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
final class ThirdPartyExtensionEffectiveStatementImpl
extends UnknownEffectiveStatementBase<String, ThirdPartyExtensionStatement>
implements ThirdPartyExtensionEffectiveStatement {
- private final @NonNull SchemaPath path;
+ private final @Nullable SchemaPath path;
private final String valueFromNamespace;
ThirdPartyExtensionEffectiveStatementImpl(final Current<String, ThirdPartyExtensionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType());
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(getNodeType()));
valueFromNamespace = stmt.getFromNamespace(ThirdPartyNamespace.class, stmt.caerbannog());
}
@Override
@Deprecated
public SchemaPath getPath() {
- return path;
+ return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
}
}
default @NonNull SchemaPath getSchemaPath() {
return schemaPath().orElseThrow();
}
+
+ @Deprecated
+ default @Nullable SchemaPath wrapSchemaPath() {
+ return SchemaPathSupport.wrap(getSchemaPath());
+ }
}
/**
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.spi.meta;
+
+import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+
+@Beta
+@Deprecated
+public abstract class SchemaPathSupport implements Immutable {
+ private static final class Enabled extends SchemaPathSupport {
+ @Override
+ SchemaPath nullableWrap(final SchemaPath path) {
+ return path;
+ }
+ }
+
+ public static final SchemaPathSupport DEFAULT = new Enabled();
+
+ private SchemaPathSupport() {
+ // Hidden on purpose
+ }
+
+ public static @Nullable SchemaPath wrap(final @Nullable SchemaPath path) {
+ return DEFAULT.nullableWrap(path);
+ }
+
+ abstract @Nullable SchemaPath nullableWrap(@Nullable SchemaPath path);
+}
Code Review / yangtools.git / commitdiff