AnyxmlSchemaLocationEffectiveStatementImpl(
final StmtContext<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType());
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
}
@Override
public void onFullDefinitionDeclared(final Mutable<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
EffectiveStatement<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- stmt.getParentContext().addToNs(AnyxmlSchemaLocationNamespace.class, ANYXML_SCHEMA_LOCATION, stmt);
+ stmt.coerceParentContext().addToNs(AnyxmlSchemaLocationNamespace.class, ANYXML_SCHEMA_LOCATION, stmt);
}
@Override
Effective(final StmtContext<Void, OpenConfigHashedValueStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(
ctx.getPublicDefinition().getStatementName());
}
Effective(final StmtContext<Void, DefaultDenyAllStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(
ctx.getPublicDefinition().getStatementName());
}
Effective(final StmtContext<Void, DefaultDenyWriteStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(
ctx.getPublicDefinition().getStatementName());
}
Effective(final StmtContext<String, AnnotationStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(
StmtContextUtils.parseIdentifier(ctx, argument()));
final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull(
@Override
public void onStatementAdded(final Mutable<String, AnnotationStatement, AnnotationEffectiveStatement> stmt) {
- final StatementDefinition parentDef = stmt.getParentContext().getPublicDefinition();
+ final StatementDefinition parentDef = stmt.coerceParentContext().getPublicDefinition();
SourceException.throwIf(YangStmtMapping.MODULE != parentDef && YangStmtMapping.SUBMODULE != parentDef,
stmt.getStatementSourceReference(),
"Annotations may only be defined at root of either a module or a submodule");
}
this.maybeQNameArgument = maybeQNameArgumentInit;
- path = ctx.getParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
container = findFirstEffectiveSubstatement(ContainerEffectiveStatement.class).get();
// TODO: this is strong binding of two API contracts. Unfortunately ContainerEffectiveStatement design is
EffectiveStatement<String, YangDataStatement>> ctx) {
// as per https://tools.ietf.org/html/rfc8040#section-8,
// yang-data is ignored unless it appears as a top-level statement
- if (ctx.getParentContext().getParentContext() != null) {
+ if (ctx.coerceParentContext().getParentContext() != null) {
ctx.setIsSupportedToBuildEffective(false);
}
}
return false;
}
if (NOCOPY_FROM_GROUPING_SET.contains(def)) {
- return !YangStmtMapping.GROUPING.equals(stmtContext.getParentContext().getPublicDefinition());
+ return !YangStmtMapping.GROUPING.equals(stmtContext.coerceParentContext().getPublicDefinition());
}
LOG.debug("Will copy {} statement {}", def, stmtContext);
}
final SchemaPath path;
- if ((StmtContextUtils.producesDeclared(getParentContext(), ChoiceStatement.class)
+ if ((StmtContextUtils.producesDeclared(parent, ChoiceStatement.class)
|| Boolean.TRUE.equals(parent.getFromNamespace(AugmentToChoiceNamespace.class, parent)))
&& isSupportedAsShorthandCase()) {
path = parentPath.createChild(qname);
final boolean isConfig;
if (configStatement != null) {
- isConfig = configStatement.getStatementArgument();
+ isConfig = configStatement.coerceStatementArgument();
// Validity check: if parent is config=false this cannot be a config=true
InferenceException.throwIf(isConfig && !parentIsConfig, getStatementSourceReference(),
OpenConfigVersionEffectiveStatementImpl(final StmtContext<SemVer, OpenConfigVersionStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType());
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
}
@Override
@Override
public void onStatementAdded(
final StmtContext.Mutable<QName, ActionStatement, EffectiveStatement<QName, ActionStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public void onStatementAdded(final Mutable<QName, AnydataStatement,
EffectiveStatement<QName, AnydataStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public void onStatementAdded(final Mutable<QName, AnyxmlStatement, AnyxmlEffectiveStatement> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
augmentAction.requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL);
final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> target =
augmentAction.mutatesEffectiveCtxPath(getSearchRoot(augmentNode),
- ChildSchemaNodeNamespace.class, augmentNode.getStatementArgument().getPathFromRoot());
+ ChildSchemaNodeNamespace.class, augmentNode.coerceStatementArgument().getPathFromRoot());
augmentAction.apply(new ModelActionBuilder.InferenceAction() {
@Override
/*
* Do not fail, if it is an uses-augment to an unknown node.
*/
- if (YangStmtMapping.USES == augmentNode.getParentContext().getPublicDefinition()) {
+ if (YangStmtMapping.USES == augmentNode.coerceParentContext().getPublicDefinition()) {
+ final SchemaNodeIdentifier augmentArg = augmentNode.coerceStatementArgument();
final Optional<StmtContext<?, ?, ?>> targetNode = ChildSchemaNodeNamespace.findNode(
- getSearchRoot(augmentNode), augmentNode.getStatementArgument());
+ getSearchRoot(augmentNode), augmentArg);
if (targetNode.isPresent() && StmtContextUtils.isUnknownStatement(targetNode.get())) {
augmentNode.setIsSupportedToBuildEffective(false);
- LOG.warn(
- "Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}",
- augmentNode.getStatementArgument(), augmentNode.getStatementSourceReference());
+ LOG.warn("Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}",
+ augmentArg, augmentNode.getStatementSourceReference());
return;
}
}
}
private static StmtContext<?, ?, ?> getSearchRoot(final StmtContext<?, ?, ?> augmentContext) {
- final StmtContext<?, ?, ?> parent = augmentContext.getParentContext();
// Augment is in uses - we need to augment instantiated nodes in parent.
+ final StmtContext<?, ?, ?> parent = augmentContext.coerceParentContext();
if (YangStmtMapping.USES == parent.getPublicDefinition()) {
return parent.getParentContext();
}
static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceCtx,
final StatementContextBase<?, ?, ?> targetCtx) {
- final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.getParentContext().getPublicDefinition()
+ final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.coerceParentContext().getPublicDefinition()
.getDeclaredRepresentationClass()) ? CopyType.ADDED_BY_USES_AUGMENTATION
: CopyType.ADDED_BY_AUGMENTATION;
/*
EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> ctx) {
super(ctx);
- this.targetPath = ctx.getStatementArgument().asSchemaPath();
+ this.targetPath = ctx.coerceStatementArgument().asSchemaPath();
final QNameModule rootModuleQName = StmtContextUtils.getRootModuleQName(ctx);
this.namespace = rootModuleQName.getNamespace();
final Mutable<?, ?, ?> baseParentCtx = baseStmtCtx.getParentContext();
if (StmtContextUtils.producesDeclared(baseParentCtx, IdentityStatement.class)) {
- final QName baseIdentityQName = baseStmtCtx.getStatementArgument();
+ final QName baseIdentityQName = baseStmtCtx.coerceStatementArgument();
final ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction(
ModelProcessingPhase.STATEMENT_DEFINITION);
final Prerequisite<StmtContext<?, ?, ?>> requiresPrereq = baseIdentityAction.requiresCtx(baseStmtCtx,
@Override
public void apply(final InferenceContext ctx) {
List<StmtContext<?, ?, ?>> derivedIdentities = baseStmtCtx.getFromNamespace(
- DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
+ DerivedIdentitiesNamespace.class, baseIdentityQName);
if (derivedIdentities == null) {
derivedIdentities = new ArrayList<>(1);
baseStmtCtx.addToNs(DerivedIdentitiesNamespace.class, baseIdentityQName, derivedIdentities);
final SourceIdentifier belongsToSourceIdentifier = getSourceIdentifier(belongsToCtx);
final Prerequisite<StmtContext<?, ?, ?>> belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx,
- ModuleNamespaceForBelongsTo.class, belongsToCtx.getStatementArgument(),
+ ModuleNamespaceForBelongsTo.class, belongsToCtx.coerceStatementArgument(),
ModelProcessingPhase.SOURCE_LINKAGE);
belongsToAction.apply(new InferenceAction() {
belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToSourceIdentifier, belongsToModuleCtx);
belongsToCtx.addToNs(BelongsToPrefixToModuleCtx.class,
- findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).getStatementArgument(),
+ findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).coerceStatementArgument(),
belongsToModuleCtx);
}
private static SourceIdentifier getSourceIdentifier(final StmtContext<String, BelongsToStatement,
EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
- return RevisionSourceIdentifier.create(belongsToCtx.getStatementArgument());
+ return RevisionSourceIdentifier.create(belongsToCtx.coerceStatementArgument());
}
@Override
@Override
public final void onStatementAdded(
final Mutable<QName, CaseStatement, EffectiveStatement<QName, CaseStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public final void onStatementAdded(
final Mutable<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public final void onStatementAdded(
final Mutable<QName, ContainerStatement, EffectiveStatement<QName, ContainerStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx);
final SchemaNodeIdentifier deviationTarget =
- (SchemaNodeIdentifier) deviateStmtCtx.getParentContext().getStatementArgument();
+ (SchemaNodeIdentifier) deviateStmtCtx.coerceParentContext().getStatementArgument();
if (!isDeviationSupported(deviateStmtCtx, deviationTarget)) {
return;
@Override
public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- throw new InferenceException(deviateStmtCtx.getParentContext().getStatementSourceReference(),
+ throw new InferenceException(deviateStmtCtx.coerceParentContext().getStatementSourceReference(),
"Deviation target '%s' not found.", deviationTarget);
}
});
EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) {
final QNameModule currentModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class,
ctx.getRoot());
- final QNameModule targetModule = ctx.getStatementArgument().getLastComponent().getModule();
+ final QNameModule targetModule = ctx.coerceStatementArgument().getLastComponent().getModule();
if (currentModule.equals(targetModule)) {
throw new InferenceException(ctx.getStatementSourceReference(),
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
-import static com.google.common.base.Verify.verifyNotNull;
-
import com.google.common.collect.ImmutableList;
import java.util.ArrayDeque;
import java.util.ArrayList;
private ExtensionEffectiveStatementImpl(
final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> ctx) {
super(ctx);
- this.qname = verifyNotNull(ctx.getStatementArgument());
+ this.qname = ctx.coerceStatementArgument();
this.schemaPath = ctx.getSchemaPath().get();
final List<UnknownSchemaNode> unknownNodesInit = new ArrayList<>();
final Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) {
super.onStatementDefinitionDeclared(stmt);
- QName stmtName = stmt.getStatementArgument();
+ QName stmtName = stmt.coerceStatementArgument();
if (OpenConfigStatements.OPENCONFIG_VERSION.getStatementName().isEqualWithoutRevision(stmtName)) {
stmtName = stmtName.withoutRevision();
}
}
this.maybeQNameArgument = maybeQNameArgumentInit;
}
- path = ctx.getParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
}
@Override
// Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling
// declarations and parent declarations which have already been declared.
checkConflict(parent, stmt);
- parent.addContext(GroupingNamespace.class, stmt.getStatementArgument(), stmt);
+ parent.addContext(GroupingNamespace.class, stmt.coerceStatementArgument(), stmt);
}
}
}
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
- final QName arg = stmt.getStatementArgument();
+ final QName arg = stmt.coerceStatementArgument();
final StmtContext<?, ?, ?> existing = parent.getFromNamespace(GroupingNamespace.class, arg);
SourceException.throwIf(existing != null, stmt.getStatementSourceReference(), "Duplicate name for grouping %s",
arg);
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
-import static com.google.common.base.Verify.verifyNotNull;
-
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.List;
final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
super(ctx);
- qname = verifyNotNull(ctx.getStatementArgument());
+ qname = ctx.coerceStatementArgument();
path = ctx.getSchemaPath().get();
addedByUses = ctx.getCopyHistory().contains(CopyType.ADDED_BY_USES);
@Override
public final void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement,
EffectiveStatement<QName, IdentityStatement>> stmt) {
- stmt.addToNs(IdentityNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.addToNs(IdentityNamespace.class, stmt.coerceStatementArgument(), stmt);
}
}
\ No newline at end of file
// initDerivedIdentities
final Set<IdentitySchemaNode> derivedIdentitiesInit = new HashSet<>();
final List<StmtContext<?, ?, ?>> derivedIdentitiesCtxList = ctx.getFromNamespace(
- DerivedIdentitiesNamespace.class, ctx.getStatementArgument());
+ DerivedIdentitiesNamespace.class, ctx.coerceStatementArgument());
if (derivedIdentitiesCtxList == null) {
this.derivedIdentities = ImmutableSet.of();
return;
*/
stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
- final String moduleName = stmt.getStatementArgument();
+ final String moduleName = stmt.coerceStatementArgument();
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
PreLinkageModuleNamespace.class, moduleName, SOURCE_PRE_LINKAGE);
ImportEffectiveStatementImpl(final StmtContext<String, ImportStatement, ?> ctx) {
super(ctx);
- moduleName = ctx.getStatementArgument();
+ moduleName = ctx.coerceStatementArgument();
final Optional<String> prefixStmt = findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class);
MissingSubstatementException.throwIf(!prefixStmt.isPresent(), ctx.getStatementSourceReference(),
"Prefix is mandatory substatement of import statement");
final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> imported;
- final String moduleName = stmt.getStatementArgument();
+ final String moduleName = stmt.coerceStatementArgument();
final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
if (revision == null) {
imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
static void onLinkageDeclared(
final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final String moduleName = stmt.getStatementArgument();
+ final String moduleName = stmt.coerceStatementArgument();
final SemVer semanticVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
final SemanticVersionImport.CompatibleCriterion criterion = semanticVersion == null
? new NoVerCompatibleCriterion(moduleName)
@Override
public final void onLinkageDeclared(
final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
- final String submoduleName = stmt.getStatementArgument();
+ final String submoduleName = stmt.coerceStatementArgument();
final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
RevisionDateStatement.class);
@Override
public final void onStatementAdded(final Mutable<QName, InputStatement,
EffectiveStatement<QName, InputStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
final QNameModule targetModule) {
final Builder<SchemaNodeIdentifier> builder = ImmutableSet.builder();
boolean replaced = false;
- for (final SchemaNodeIdentifier arg : ctx.getStatementArgument()) {
+ for (final SchemaNodeIdentifier arg : ctx.coerceStatementArgument()) {
final QName qname = arg.getLastComponent();
if (!targetModule.equals(qname.getModule())) {
final QName newQname = ctx.getFromNamespace(QNameCacheNamespace.class, qname.withModule(targetModule));
@Override
public void onStatementAdded(final Mutable<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public final void onStatementAdded(
final Mutable<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public final void onStatementAdded(
final Mutable<QName, ListStatement, EffectiveStatement<QName, ListStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
private static void addToSemVerModuleNamespace(
final Mutable<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> stmt,
final SourceIdentifier moduleIdentifier) {
- final String moduleName = stmt.getStatementArgument();
+ final String moduleName = stmt.coerceStatementArgument();
final SemVer moduleSemVer = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
final SemVerSourceIdentifier id = SemVerSourceIdentifier.create(moduleName, moduleSemVer);
stmt.addToNs(SemanticVersionModuleNamespace.class, id, stmt);
@Override
public final void onStatementAdded(
final Mutable<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
-import static com.google.common.base.Verify.verifyNotNull;
-
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
NotificationEffectiveStatementImpl(
final StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
super(ctx);
- this.qname = verifyNotNull(ctx.getStatementArgument());
+ this.qname = ctx.coerceStatementArgument();
this.path = ctx.getSchemaPath().get();
// initSubstatementCollections
@Override
public final void onStatementAdded(final Mutable<QName, OutputStatement,
EffectiveStatement<QName, OutputStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
RefineEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
super(ctx);
- qname = verifyNotNull(ctx.getStatementArgument().getLastComponent());
+ qname = verifyNotNull(ctx.coerceStatementArgument().getLastComponent());
path = ctx.getSchemaPath().get();
refineTargetNode = (SchemaNode) ctx.getEffectOfStatement().iterator().next().buildEffective();
@Override
public final void onStatementAdded(
final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.getStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
@Override
@Override
public final void onLinkageDeclared(
final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
- final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.getStatementArgument(),
+ final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.coerceStatementArgument(),
StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()));
final StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>
final Collection<StmtContext<QName, BaseStatement, ?>> baseStatements =
StmtContextUtils.findAllDeclaredSubstatements(stmt, BaseStatement.class);
for (StmtContext<QName, BaseStatement, ?> baseStmt : baseStatements) {
- final QName baseIdentity = baseStmt.getStatementArgument();
+ final QName baseIdentity = baseStmt.coerceStatementArgument();
final StmtContext<?, ?, ?> stmtCtx = stmt.getFromNamespace(IdentityNamespace.class, baseIdentity);
InferenceException.throwIfNull(stmtCtx, stmt.getStatementSourceReference(),
"Referenced base identity '%s' doesn't exist in given scope (module, imported modules, submodules)",
// First look up the proper base type
final TypeEffectiveStatement<TypeStatement> typeStmt;
- switch (ctx.getStatementArgument()) {
+ switch (ctx.coerceStatementArgument()) {
case BINARY:
typeStmt = BuiltinEffectiveStatement.BINARY;
break;
// Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling
// declarations and parent declarations which have already been declared.
checkConflict(parent, stmt);
- parent.addContext(TypeNamespace.class, stmt.getStatementArgument(), stmt);
+ parent.addContext(TypeNamespace.class, stmt.coerceStatementArgument(), stmt);
}
}
}
}
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
- final QName arg = stmt.getStatementArgument();
+ final QName arg = stmt.coerceStatementArgument();
final StmtContext<?, ?, ?> existing = parent.getFromNamespace(TypeNamespace.class, arg);
// RFC7950 sections 5.5 and 6.2.1: identifiers must not be shadowed
SourceException.throwIf(existing != null, stmt.getStatementSourceReference(), "Duplicate name for typedef %s",
// initGroupingPath
final StmtContext<?, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> grpCtx =
- ctx.getFromNamespace(GroupingNamespace.class, ctx.getStatementArgument());
+ ctx.getFromNamespace(GroupingNamespace.class, ctx.coerceStatementArgument());
this.groupingPath = grpCtx.getSchemaPath().get();
// initCopyType
return false;
}
if (NOCOPY_FROM_GROUPING_SET.contains(def)) {
- return !YangStmtMapping.GROUPING.equals(stmtContext.getParentContext().getPublicDefinition());
+ return !YangStmtMapping.GROUPING.equals(stmtContext.coerceParentContext().getPublicDefinition());
}
LOG.trace("Will copy {} statement {}", def, stmtContext);
if (StmtContextUtils.isUnknownStatement(refineTargetNodeCtx)) {
LOG.trace("Refine node '{}' in uses '{}' has target node unknown statement '{}'. "
+ "Refine has been skipped. At line: {}", subStmtCtx.getStatementArgument(),
- subStmtCtx.getParentContext().getStatementArgument(),
+ subStmtCtx.coerceParentContext().getStatementArgument(),
refineTargetNodeCtx.getStatementArgument(), subStmtCtx.getStatementSourceReference());
subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx);
return;
SourceException.throwIf(!isSupportedRefineTarget(refineSubstatementCtx, refineTargetNodeCtx),
refineSubstatementCtx.getStatementSourceReference(),
"Error in module '%s' in the refine of uses '%s': can not perform refine of '%s' for the target '%s'.",
- refineSubstatementCtx.getRoot().getStatementArgument(), refineSubstatementCtx.getParentContext()
- .getStatementArgument(), refineSubstatementCtx.getPublicDefinition(), refineTargetNodeCtx
- .getPublicDefinition());
+ refineSubstatementCtx.getRoot().getStatementArgument(),
+ refineSubstatementCtx.coerceParentContext().getStatementArgument(),
+ refineSubstatementCtx.getPublicDefinition(), refineTargetNodeCtx.getPublicDefinition());
if (isAllowedToAddByRefine(refineSubstatementDef)) {
refineTargetNodeCtx.addEffectiveSubstatement(refineSubstatementCtx);
ThirdPartyExtensionEffectiveStatementImpl(final StmtContext<String, ThirdPartyExtensionStatement, ?> ctx) {
super(ctx);
- path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType());
+ path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
valueFromNamespace = ctx.getFromNamespace(ThirdPartyNamespace.class, ctx);
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.base.VerifyException;
import com.google.common.collect.Iterables;
import com.google.common.collect.Streams;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;
-import javax.annotation.Nullable;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
*
* @return context of parent of statement, or null if this is the root statement.
*/
- @Nullable
- StmtContext<?, ?, ?> getParentContext();
+ @Nullable StmtContext<?, ?, ?> getParentContext();
+
+ /**
+ * Return the parent statement context, forcing a VerifyException if this is the root statement.
+ *
+ * @return context of parent of statement
+ * @throws VerifyException if this statement is the root statement
+ */
+ default @NonNull StmtContext<?, ?, ?> coerceParentContext() {
+ return verifyNotNull(getParentContext(), "Root context %s does not have a parent", this);
+ }
+
+ /**
+ * Return the statement argument in literal format.
+ *
+ * @return raw statement argument string, or null if this statement does not have an argument.
+ */
+ @Nullable String rawStatementArgument();
/**
* Return the statement argument in literal format.
*
* @return raw statement argument string
+ * @throws VerifyException if this statement does not have an argument
*/
- @Nullable
- String rawStatementArgument();
+ default @NonNull String coerceRawStatementArgument() {
+ return verifyNotNull(rawStatementArgument(), "Statement context %s does not have an argument", this);
+ }
- @Nullable
- A getStatementArgument();
+ /**
+ * Return the statement argument.
+ *
+ * @return statement argument, or null if this statement does not have an argument
+ */
+ @Nullable A getStatementArgument();
+
+ /**
+ * Return the statement argument in literal format.
+ *
+ * @return raw statement argument string
+ * @throws VerifyException if this statement does not have an argument
+ */
+ default @NonNull A coerceStatementArgument() {
+ return verifyNotNull(getStatementArgument(), "Statement context %s does not have an argument", this);
+ }
/**
* Return the {@link SchemaPath} of this statement. Not all statements have a SchemaPath, in which case
* @return Value, or null if there is no element
* @throws NamespaceNotAvailableException when the namespace is not available.
*/
- @NonNull <K, V, T extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(Class<N> type, T key) ;
+ @NonNull <K, V, T extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(Class<N> type, T key);
- <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(
- Class<N> type);
+ <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(Class<N> type);
<K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(Class<N> type);
@Override
Mutable<?, ?, ?> getParentContext();
+ @Override
+ default Mutable<?, ?, ?> coerceParentContext() {
+ return verifyNotNull(getParentContext(), "Root context %s does not have a parent", this);
+ }
+
/**
* Associate a value with a key within a namespace.
*
public static boolean isInExtensionBody(final StmtContext<?, ?, ?> stmtCtx) {
StmtContext<?, ?, ?> current = stmtCtx;
- while (current.getParentContext().getParentContext() != null) {
+ while (current.coerceParentContext().getParentContext() != null) {
current = current.getParentContext();
if (isUnknownStatement(current)) {
return true;
if (YangStmtMapping.IF_FEATURE.equals(stmt.getPublicDefinition())) {
containsIfFeature = true;
@SuppressWarnings("unchecked")
- final Predicate<Set<QName>> argument = (Predicate<Set<QName>>) stmt.getStatementArgument();
+ final Predicate<Set<QName>> argument = (Predicate<Set<QName>>) stmt.coerceStatementArgument();
if (argument.test(supportedFeatures)) {
isSupported = true;
} else {
requireNonNull(ancestorType);
requireNonNull(ancestorChildType);
- StmtContext<?, ?, ?> current = ctx.getParentContext();
+ StmtContext<?, ?, ?> current = ctx.coerceParentContext();
StmtContext<?, ?, ?> parent = current.getParentContext();
while (parent != null) {
if (ancestorType.equals(current.getPublicDefinition())) {
private static boolean isRelevantForIfFeatureAndWhenOnListKeysCheck(final StmtContext<?, ?, ?> ctx) {
return YangVersion.VERSION_1_1.equals(ctx.getRootVersion())
&& StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.LIST)
- && StmtContextUtils.findFirstDeclaredSubstatement(ctx.getParentContext(), KeyStatement.class) != null;
+ && StmtContextUtils.findFirstDeclaredSubstatement(ctx.coerceParentContext(),
+ KeyStatement.class) != null;
}
private static boolean isListKey(final StmtContext<?, ?, ?> leafStmtCtx,
final StmtContext<Collection<SchemaNodeIdentifier>, ?, ?> keyStmtCtx) {
- for (final SchemaNodeIdentifier keyIdentifier : keyStmtCtx.getStatementArgument()) {
+ for (final SchemaNodeIdentifier keyIdentifier : keyStmtCtx.coerceStatementArgument()) {
if (leafStmtCtx.getStatementArgument().equals(keyIdentifier.getLastComponent())) {
return true;
}
RevisionStatement.class)) {
if (revision == null && subStmt.getStatementArgument() != null) {
revision = (Revision) subStmt.getStatementArgument();
- } else if (subStmt.getStatementArgument() != null
- && ((Revision) subStmt.getStatementArgument()).compareTo(revision) > 0) {
- revision = (Revision) subStmt.getStatementArgument();
+ } else {
+ final Revision subArg = (Revision) subStmt.getStatementArgument();
+ if (subArg != null && subArg.compareTo(revision) > 0) {
+ revision = subArg;
+ }
}
}
}
Code Review / yangtools.git / commitdiff