@Override
protected OpenConfigVersionStatement createDeclared(final StmtContext<SemVer, OpenConfigVersionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new OpenConfigVersionStatementImpl(ctx.coerceStatementArgument(), substatements);
+ return new OpenConfigVersionStatementImpl(ctx.getArgument(), substatements);
}
@Override
@Override
protected final D createEmptyDeclared(final StmtContext<Boolean, D, ?> ctx) {
- return ctx.coerceStatementArgument() ? emptyDeclaredTrue : emptyDeclaredFalse;
+ return ctx.getArgument() ? emptyDeclaredTrue : emptyDeclaredFalse;
}
@Override
@Override
protected final D createEmptyDeclared(final StmtContext<A, D, ?> ctx) {
- return declaredCache.getUnchecked(ctx.coerceStatementArgument());
+ return declaredCache.getUnchecked(ctx.getArgument());
}
protected abstract @NonNull D createEmptyDeclared(@NonNull A argument);
@Override
protected final D createDeclared(final StmtContext<A, D, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return createDeclared(ctx.coerceStatementArgument(), substatements);
+ return createDeclared(ctx.getArgument(), substatements);
}
protected abstract @NonNull D createDeclared(@NonNull A argument,
@Override
public QName adaptArgumentValue(final StmtContext<QName, D, E> ctx, final QNameModule targetModule) {
- return ctx.coerceStatementArgument().bindTo(targetModule).intern();
+ return ctx.getArgument().bindTo(targetModule).intern();
}
protected static final int historyAndStatusFlags(final CopyHistory history,
@Override
public final void onStatementAdded(final Mutable<QName, D, E> stmt) {
- stmt.coerceParentContext().addToNs(SchemaTreeNamespace.class, stmt.coerceStatementArgument(), stmt);
+ stmt.coerceParentContext().addToNs(SchemaTreeNamespace.class, stmt.getArgument(), stmt);
}
// Non-final because {@code input} and {@code output} are doing their own thing.
@Override
protected ActionStatement createDeclared(final StmtContext<QName, ActionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularActionStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularActionStatement(ctx.getArgument(), substatements);
}
@Override
protected ActionStatement createEmptyDeclared(final StmtContext<QName, ActionStatement, ?> ctx) {
- return new EmptyActionStatement(ctx.coerceStatementArgument());
+ return new EmptyActionStatement(ctx.getArgument());
}
@Override
@Override
protected AnydataStatement createDeclared(final StmtContext<QName, AnydataStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularAnydataStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularAnydataStatement(ctx.getArgument(), substatements);
}
@Override
protected AnydataStatement createEmptyDeclared(final StmtContext<QName, AnydataStatement, ?> ctx) {
- return new EmptyAnydataStatement(ctx.coerceStatementArgument());
+ return new EmptyAnydataStatement(ctx.getArgument());
}
@Override
@Override
protected AnyxmlStatement createDeclared(final StmtContext<QName, AnyxmlStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularAnyxmlStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularAnyxmlStatement(ctx.getArgument(), substatements);
}
@Override
protected AnyxmlStatement createEmptyDeclared(final StmtContext<QName, AnyxmlStatement, ?> ctx) {
- return new EmptyAnyxmlStatement(ctx.coerceStatementArgument());
+ return new EmptyAnyxmlStatement(ctx.getArgument());
}
@Override
@Override
protected ArgumentStatement createDeclared(final StmtContext<QName, ArgumentStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularArgumentStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularArgumentStatement(ctx.getArgument(), substatements);
}
@Override
protected ArgumentStatement createEmptyDeclared(final StmtContext<QName, ArgumentStatement, ?> ctx) {
- return new EmptyArgumentStatement(ctx.coerceStatementArgument());
+ return new EmptyArgumentStatement(ctx.getArgument());
}
@Override
final ModelActionBuilder augmentAction = augmentNode.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
augmentAction.requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL);
final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> target = augmentAction.mutatesEffectiveCtxPath(
- getSearchRoot(augmentNode), SchemaTreeNamespace.class,
- augmentNode.coerceStatementArgument().getNodeIdentifiers());
+ getSearchRoot(augmentNode), SchemaTreeNamespace.class, augmentNode.getArgument().getNodeIdentifiers());
augmentAction.apply(new InferenceAction() {
@Override
final Optional<? extends StmtContext<?, ?, ?>> optPrevCopy = targetCtx.getPreviousCopyCtx();
if (optPrevCopy.isPresent()) {
final StmtContext<?, ?, ?> original = optPrevCopy.get();
- final Object origArg = original.coerceStatementArgument();
+ final Object origArg = original.getArgument();
Verify.verify(origArg instanceof QName, "Unexpected statement argument %s", origArg);
if (sourceStmtQName.getModule().equals(((QName) origArg).getModule())
public void onStatementDefinitionDeclared(final Mutable<QName, BaseStatement, BaseEffectiveStatement> baseStmtCtx) {
final Mutable<?, ?, ?> baseParentCtx = baseStmtCtx.coerceParentContext();
if (baseParentCtx.producesDeclared(IdentityStatement.class)) {
- final QName baseIdentityQName = baseStmtCtx.coerceStatementArgument();
+ final QName baseIdentityQName = baseStmtCtx.getArgument();
final ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction(
ModelProcessingPhase.STATEMENT_DEFINITION);
baseIdentityAction.requiresCtx(baseStmtCtx, IdentityNamespace.class, baseIdentityQName,
@Override
protected BaseStatement createDeclared(final StmtContext<QName, BaseStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularBaseStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularBaseStatement(ctx.getArgument(), substatements);
}
@Override
protected BaseStatement createEmptyDeclared(final StmtContext<QName, BaseStatement, ?> ctx) {
- return new EmptyBaseStatement(ctx.coerceStatementArgument());
+ return new EmptyBaseStatement(ctx.getArgument());
}
@Override
final SourceIdentifier belongsToSourceIdentifier = getSourceIdentifier(belongsToCtx);
final Prerequisite<StmtContext<?, ?, ?>> belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx,
- ModuleNamespaceForBelongsTo.class, belongsToCtx.coerceStatementArgument(),
- ModelProcessingPhase.SOURCE_LINKAGE);
+ ModuleNamespaceForBelongsTo.class, belongsToCtx.getArgument(), ModelProcessingPhase.SOURCE_LINKAGE);
belongsToAction.apply(new InferenceAction() {
@Override
belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToSourceIdentifier, belongsToModuleCtx);
belongsToCtx.addToNs(BelongsToPrefixToModuleCtx.class,
- findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).coerceStatementArgument(),
+ findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).getArgument(),
belongsToModuleCtx);
}
private static SourceIdentifier getSourceIdentifier(final StmtContext<String, BelongsToStatement,
BelongsToEffectiveStatement> belongsToCtx) {
- return RevisionSourceIdentifier.create(belongsToCtx.coerceStatementArgument());
+ return RevisionSourceIdentifier.create(belongsToCtx.getArgument());
}
@Override
@Override
protected final BitStatement createDeclared(final StmtContext<String, BitStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularBitStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularBitStatement(ctx.getArgument(), substatements);
}
@Override
protected final BitStatement createEmptyDeclared(final StmtContext<String, BitStatement, ?> ctx) {
- return new EmptyBitStatement(ctx.coerceStatementArgument());
+ return new EmptyBitStatement(ctx.getArgument());
}
@Override
final StatementSource source = ctx.source();
switch (source) {
case CONTEXT:
- return new RegularUndeclaredCaseStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularUndeclaredCaseStatement(ctx.getArgument(), substatements);
case DECLARATION:
- return new RegularCaseStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularCaseStatement(ctx.getArgument(), substatements);
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
final StatementSource source = ctx.source();
switch (source) {
case CONTEXT:
- return new EmptyUndeclaredCaseStatement(ctx.coerceStatementArgument());
+ return new EmptyUndeclaredCaseStatement(ctx.getArgument());
case DECLARATION:
- return new EmptyCaseStatement(ctx.coerceStatementArgument());
+ return new EmptyCaseStatement(ctx.getArgument());
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
@Override
protected final ChoiceStatement createDeclared(@NonNull final StmtContext<QName, ChoiceStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularChoiceStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularChoiceStatement(ctx.getArgument(), substatements);
}
@Override
protected final ChoiceStatement createEmptyDeclared(@NonNull final StmtContext<QName, ChoiceStatement, ?> ctx) {
- return new EmptyChoiceStatement(ctx.coerceStatementArgument());
+ return new EmptyChoiceStatement(ctx.getArgument());
}
@Override
@Override
protected ConfigStatement createDeclared(final StmtContext<Boolean, ConfigStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularConfigStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularConfigStatement(ctx.getArgument(), substatements);
}
@Override
@Override
protected final ContainerStatement createDeclared(final StmtContext<QName, ContainerStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularContainerStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularContainerStatement(ctx.getArgument(), substatements);
}
@Override
protected final ContainerStatement createEmptyDeclared(final StmtContext<QName, ContainerStatement, ?> ctx) {
- return new EmptyContainerStatement(ctx.coerceStatementArgument());
+ return new EmptyContainerStatement(ctx.getArgument());
}
@Override
@Override
protected final DeviateStatement createDeclared(final StmtContext<DeviateKind, DeviateStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new DeviateStatementImpl(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new DeviateStatementImpl(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
@Override
public void onFullDefinitionDeclared(
final Mutable<Absolute, DeviationStatement, DeviationEffectiveStatement> ctx) {
- final QNameModule currentModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class,
- ctx.getRoot());
- final QNameModule targetModule = Iterables.getLast(ctx.coerceStatementArgument().getNodeIdentifiers())
- .getModule();
+ final QNameModule currentModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot());
+ final QNameModule targetModule = Iterables.getLast(ctx.getArgument().getNodeIdentifiers()).getModule();
if (currentModule.equals(targetModule)) {
throw new InferenceException(ctx.sourceReference(),
@Override
protected DeviationStatement createDeclared(final StmtContext<Absolute, DeviationStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new DeviationStatementImpl(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new DeviationStatementImpl(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
@Override
protected final EnumStatement createDeclared(final StmtContext<String, EnumStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularEnumStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularEnumStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected final EnumStatement createEmptyDeclared(final StmtContext<String, EnumStatement, ?> ctx) {
- return new EmptyEnumStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyEnumStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
final Mutable<QName, ExtensionStatement, ExtensionEffectiveStatement> stmt) {
super.onStatementDefinitionDeclared(stmt);
- QName stmtName = stmt.coerceStatementArgument();
+ QName stmtName = stmt.getArgument();
if (OpenConfigStatements.OPENCONFIG_VERSION.getStatementName().isEqualWithoutRevision(stmtName)) {
stmtName = stmtName.withoutRevision();
}
YinElementStatement.class);
stmt.addToNs(StatementDefinitionNamespace.class, stmt.argument(),
- new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(stmt.coerceStatementArgument(),
- argument != null ? argument.argument() : null,
- yinElement != null && yinElement.coerceStatementArgument())));
+ new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(stmt.getArgument(),
+ argument != null ? argument.argument() : null, yinElement != null && yinElement.getArgument())));
}
@Override
@Override
protected ExtensionStatement createDeclared(final StmtContext<QName, ExtensionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularExtensionStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularExtensionStatement(ctx.getArgument(), substatements);
}
@Override
protected ExtensionStatement createEmptyDeclared(final StmtContext<QName, ExtensionStatement, ?> ctx) {
- return new EmptyExtensionStatement(ctx.coerceStatementArgument());
+ return new EmptyExtensionStatement(ctx.getArgument());
}
@Override
@Override
public void onFullDefinitionDeclared(final Mutable<QName, FeatureStatement, FeatureEffectiveStatement> stmt) {
super.onFullDefinitionDeclared(stmt);
- stmt.addContext(FeatureNamespace.class, stmt.coerceStatementArgument(), stmt);
+ stmt.addContext(FeatureNamespace.class, stmt.getArgument(), stmt);
}
@Override
@Override
protected FeatureStatement createDeclared(final StmtContext<QName, FeatureStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularFeatureStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularFeatureStatement(ctx.getArgument(), substatements);
}
@Override
protected FeatureStatement createEmptyDeclared(@NonNull final StmtContext<QName, FeatureStatement, ?> ctx) {
- return new EmptyFeatureStatement(ctx.coerceStatementArgument());
+ return new EmptyFeatureStatement(ctx.getArgument());
}
@Override
@Override
protected FractionDigitsStatement createDeclared(final StmtContext<Integer, FractionDigitsStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularFractionDigitsStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularFractionDigitsStatement(ctx.getArgument(), substatements);
}
@Override
protected FractionDigitsStatement createEmptyDeclared(final StmtContext<Integer, FractionDigitsStatement, ?> ctx) {
- final Integer argument = ctx.coerceStatementArgument();
+ final Integer argument = ctx.getArgument();
return verifyNotNull(EMPTY_DECLS.get(argument), "No declared instance for %s", argument);
}
// 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.coerceStatementArgument(), stmt);
+ parent.addContext(GroupingNamespace.class, stmt.getArgument(), stmt);
}
}
}
protected final GroupingStatement createDeclared(final StmtContext<QName, GroupingStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
checkDeclaredConflict(ctx);
- return new RegularGroupingStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularGroupingStatement(ctx.getArgument(), substatements);
}
@Override
protected final GroupingStatement createEmptyDeclared(final StmtContext<QName, GroupingStatement, ?> ctx) {
checkDeclaredConflict(ctx);
- return new EmptyGroupingStatement(ctx.coerceStatementArgument());
+ return new EmptyGroupingStatement(ctx.getArgument());
}
@Override
}
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
- final QName arg = stmt.coerceStatementArgument();
+ final QName arg = stmt.getArgument();
final StmtContext<?, ?, ?> existing = parent.getFromNamespace(GroupingNamespace.class, arg);
SourceException.throwIf(existing != null, stmt.sourceReference(), "Duplicate name for grouping %s", arg);
}
@Override
public final void onStatementDefinitionDeclared(
final Mutable<QName, IdentityStatement, IdentityEffectiveStatement> stmt) {
- final QName qname = stmt.coerceStatementArgument();
+ final QName qname = stmt.getArgument();
final StmtContext<?, ?, ?> prev = stmt.getFromNamespace(IdentityNamespace.class, qname);
SourceException.throwIf(prev != null, stmt.sourceReference(), "Duplicate identity definition %s", qname);
stmt.addToNs(IdentityNamespace.class, qname, stmt);
@Override
protected final IdentityStatement createDeclared(final StmtContext<QName, IdentityStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularIdentityStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularIdentityStatement(ctx.getArgument(), substatements);
}
@Override
protected final IdentityStatement createEmptyDeclared(@NonNull final StmtContext<QName, IdentityStatement, ?> ctx) {
- return new EmptyIdentityStatement(ctx.coerceStatementArgument());
+ return new EmptyIdentityStatement(ctx.getArgument());
}
@Override
final ModelActionBuilder verifyFeatures = stmt.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
final Map<Prerequisite<?>, QName> backRef = new HashMap<>();
- for (QName feature : stmt.coerceStatementArgument().getReferencedFeatures()) {
+ for (QName feature : stmt.getArgument().getReferencedFeatures()) {
backRef.put(verifyFeatures.requiresCtx(stmt, FeatureNamespace.class, feature,
ModelProcessingPhase.EFFECTIVE_MODEL), feature);
}
@Override
protected final IfFeatureStatement createDeclared(final StmtContext<IfFeatureExpr, IfFeatureStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularIfFeatureStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularIfFeatureStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected final IfFeatureStatement createEmptyDeclared(
final StmtContext<IfFeatureExpr, IfFeatureStatement, ?> ctx) {
- return new EmptyIfFeatureStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyIfFeatureStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
*/
stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
- final String moduleName = stmt.coerceStatementArgument();
+ final String moduleName = stmt.getArgument();
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
PreLinkageModuleNamespace.class, moduleName, SOURCE_PRE_LINKAGE);
static void onLinkageDeclared(final Mutable<String, ImportStatement, ImportEffectiveStatement> stmt) {
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> imported;
- final String moduleName = stmt.coerceStatementArgument();
+ final String moduleName = stmt.getArgument();
final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
if (revision == null) {
imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
static void onLinkageDeclared(final Mutable<String, ImportStatement, ImportEffectiveStatement> stmt) {
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final String moduleName = stmt.coerceStatementArgument();
+ final String moduleName = stmt.getArgument();
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, IncludeEffectiveStatement> stmt) {
- final String submoduleName = stmt.coerceStatementArgument();
- final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
- RevisionDateStatement.class);
+ final String submoduleName = stmt.getArgument();
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt, RevisionDateStatement.class);
final ModelActionBuilder includeAction = stmt.newInferenceAction(SOURCE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> requiresCtxPrerequisite;
NamespaceKeyCriterion.latestRevisionModule(submoduleName), SOURCE_LINKAGE);
} else {
requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
- RevisionSourceIdentifier.create(submoduleName, Optional.of(revision.argument())),
- SOURCE_LINKAGE);
+ RevisionSourceIdentifier.create(submoduleName, Optional.of(revision.argument())), SOURCE_LINKAGE);
}
includeAction.apply(new InferenceAction() {
@Override
protected final IncludeStatement createDeclared(final StmtContext<String, IncludeStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularIncludeStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularIncludeStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected final IncludeStatement createEmptyDeclared(final StmtContext<String, IncludeStatement, ?> ctx) {
- return new EmptyIncludeStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyIncludeStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
final StatementSource source = ctx.source();
switch (source) {
case CONTEXT:
- return new RegularUndeclaredInputStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularUndeclaredInputStatement(ctx.getArgument(), substatements);
case DECLARATION:
- return new RegularInputStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularInputStatement(ctx.getArgument(), substatements);
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
final StatementSource source = ctx.source();
switch (source) {
case CONTEXT:
- return new EmptyUndeclaredInputStatement(ctx.coerceStatementArgument());
+ return new EmptyUndeclaredInputStatement(ctx.getArgument());
case DECLARATION:
- return new EmptyInputStatement(ctx.coerceStatementArgument());
+ return new EmptyInputStatement(ctx.getArgument());
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
final QNameModule targetModule) {
final Builder<QName> builder = ImmutableSet.builder();
boolean replaced = false;
- for (final QName qname : ctx.coerceStatementArgument()) {
+ for (final QName qname : ctx.getArgument()) {
if (!targetModule.equals(qname.getModule())) {
final QName newQname = qname.bindTo(targetModule).intern();
builder.add(newQname);
@Override
protected KeyStatement createDeclared(final StmtContext<Set<QName>, KeyStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularKeyStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularKeyStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected KeyStatement createEmptyDeclared(final StmtContext<Set<QName>, KeyStatement, ?> ctx) {
- return new EmptyKeyStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyKeyStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected LeafStatement createDeclared(final StmtContext<QName, LeafStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularLeafStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularLeafStatement(ctx.getArgument(), substatements);
}
@Override
protected LeafStatement createEmptyDeclared(final StmtContext<QName, LeafStatement, ?> ctx) {
- return new EmptyLeafStatement(ctx.coerceStatementArgument());
+ return new EmptyLeafStatement(ctx.getArgument());
}
@Override
@Override
protected final LeafListStatement createDeclared(final StmtContext<QName, LeafListStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularLeafListStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularLeafListStatement(ctx.getArgument(), substatements);
}
@Override
protected final LeafListStatement createEmptyDeclared(final StmtContext<QName, LeafListStatement, ?> ctx) {
- return new EmptyLeafListStatement(ctx.coerceStatementArgument());
+ return new EmptyLeafListStatement(ctx.getArgument());
}
@Override
@Override
protected LengthStatement createDeclared(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularLengthStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularLengthStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected LengthStatement createEmptyDeclared(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx) {
- return new EmptyLengthStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyLengthStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected final ListStatement createDeclared(final StmtContext<QName, ListStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularListStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularListStatement(ctx.getArgument(), substatements);
}
@Override
protected final ListStatement createEmptyDeclared(final StmtContext<QName, ListStatement, ?> ctx) {
- return new EmptyListStatement(ctx.coerceStatementArgument());
+ return new EmptyListStatement(ctx.getArgument());
}
@Override
@Override
protected MandatoryStatement createDeclared(final StmtContext<Boolean, MandatoryStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularMandatoryStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularMandatoryStatement(ctx.getArgument(), substatements);
}
@Override
@Override
protected MaxElementsStatement createDeclared(final StmtContext<String, MaxElementsStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularMaxElementsStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularMaxElementsStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected MaxElementsStatement createEmptyDeclared(final StmtContext<String, MaxElementsStatement, ?> ctx) {
- return new EmptyMaxElementsStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyMaxElementsStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected ModifierStatement createDeclared(final StmtContext<ModifierKind, ModifierStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularModifierStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularModifierStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected ModifierStatement createEmptyDeclared(final StmtContext<ModifierKind, ModifierStatement, ?> ctx) {
- return new EmptyModifierStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyModifierStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern();
stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule);
- stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.coerceStatementArgument().getLocalName(),
- revisionDate));
+ stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getArgument().getLocalName(), revisionDate));
}
@Override
@Override
protected final ModuleStatement createDeclared(final StmtContext<UnqualifiedQName, ModuleStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new ModuleStatementImpl(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new ModuleStatementImpl(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
@Override
protected MustStatement createDeclared(final StmtContext<QualifiedBound, MustStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularMustStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularMustStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected MustStatement createEmptyDeclared(final StmtContext<QualifiedBound, MustStatement, ?> ctx) {
- return new EmptyMustStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyMustStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected NamespaceStatement createDeclared(@NonNull final StmtContext<URI, NamespaceStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularNamespaceStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularNamespaceStatement(ctx.getArgument(), substatements);
}
@Override
protected NamespaceStatement createEmptyDeclared(final StmtContext<URI, NamespaceStatement, ?> ctx) {
- return new EmptyNamespaceStatement(ctx.coerceStatementArgument());
+ return new EmptyNamespaceStatement(ctx.getArgument());
}
@Override
@Override
protected final NotificationStatement createDeclared(final StmtContext<QName, NotificationStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularNotificationStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularNotificationStatement(ctx.getArgument(), substatements);
}
@Override
protected final NotificationStatement createEmptyDeclared(final StmtContext<QName, NotificationStatement, ?> ctx) {
- return new EmptyNotificationStatement(ctx.coerceStatementArgument());
+ return new EmptyNotificationStatement(ctx.getArgument());
}
@Override
@Override
protected OrderedByStatement createDeclared(final StmtContext<Ordering, OrderedByStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularOrderedByStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularOrderedByStatement(ctx.getArgument(), substatements);
}
@Override
protected OrderedByStatement createEmptyDeclared(final StmtContext<Ordering, OrderedByStatement, ?> ctx) {
- final Ordering argument = ctx.coerceStatementArgument();
+ final Ordering argument = ctx.getArgument();
switch (argument) {
case SYSTEM:
return EMPTY_SYSTEM_DECL;
final StatementSource source = ctx.source();
switch (source) {
case CONTEXT:
- return new RegularUndeclaredOutputStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularUndeclaredOutputStatement(ctx.getArgument(), substatements);
case DECLARATION:
- return new RegularOutputStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularOutputStatement(ctx.getArgument(), substatements);
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
final StatementSource source = ctx.source();
switch (source) {
case CONTEXT:
- return new EmptyUndeclaredOutputStatement(ctx.coerceStatementArgument());
+ return new EmptyUndeclaredOutputStatement(ctx.getArgument());
case DECLARATION:
- return new EmptyOutputStatement(ctx.coerceStatementArgument());
+ return new EmptyOutputStatement(ctx.getArgument());
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
@Override
protected PathStatement createDeclared(final StmtContext<PathExpression, PathStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularPathStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularPathStatement(ctx.getArgument(), substatements);
}
@Override
protected PathStatement createEmptyDeclared(final StmtContext<PathExpression, PathStatement, ?> ctx) {
- return new EmptyPathStatement(ctx.coerceStatementArgument());
+ return new EmptyPathStatement(ctx.getArgument());
}
@Override
@Override
protected final PatternStatement createDeclared(final StmtContext<PatternExpression, PatternStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularPatternStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularPatternStatement(ctx.getArgument(), substatements);
}
@Override
protected final PatternStatement createEmptyDeclared(
final StmtContext<PatternExpression, PatternStatement, ?> ctx) {
- return new EmptyPatternStatement(ctx.coerceStatementArgument());
+ return new EmptyPatternStatement(ctx.getArgument());
}
@Override
@Override
protected RangeStatement createDeclared(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularRangeStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularRangeStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected RangeStatement createEmptyDeclared(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx) {
- return new EmptyRangeStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyRangeStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected final RefineStatement createDeclared(final StmtContext<Descendant, RefineStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RefineStatementImpl(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RefineStatementImpl(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
@Override
protected RequireInstanceStatement createDeclared(final StmtContext<Boolean, RequireInstanceStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularRequireInstanceStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularRequireInstanceStatement(ctx.getArgument(), substatements);
}
@Override
@Override
protected RevisionStatement createDeclared(final StmtContext<Revision, RevisionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularRevisionStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularRevisionStatement(ctx.getArgument(), substatements);
}
@Override
protected RevisionStatement createEmptyDeclared(final StmtContext<Revision, RevisionStatement, ?> ctx) {
- return new EmptyRevisionStatement(ctx.coerceStatementArgument());
+ return new EmptyRevisionStatement(ctx.getArgument());
}
@Override
@Override
protected RevisionDateStatement createDeclared(final StmtContext<Revision, RevisionDateStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularRevisionDateStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularRevisionDateStatement(ctx.getArgument(), substatements);
}
@Override
protected RevisionDateStatement createEmptyDeclared(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
- return new EmptyRevisionDateStatement(ctx.coerceStatementArgument());
+ return new EmptyRevisionDateStatement(ctx.getArgument());
}
@Override
@Override
protected final RpcStatement createDeclared(final StmtContext<QName, RpcStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularRpcStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularRpcStatement(ctx.getArgument(), substatements);
}
@Override
protected final RpcStatement createEmptyDeclared(final StmtContext<QName, RpcStatement, ?> ctx) {
- return new EmptyRpcStatement(ctx.coerceStatementArgument());
+ return new EmptyRpcStatement(ctx.getArgument());
}
@Override
@Override
protected StatusStatement createDeclared(final StmtContext<Status, StatusStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularStatusStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularStatusStatement(ctx.getArgument(), substatements);
}
@Override
protected StatusStatement createEmptyDeclared(final StmtContext<Status, StatusStatement, ?> ctx) {
- final Status argument = ctx.coerceStatementArgument();
+ final Status argument = ctx.getArgument();
switch (argument) {
case CURRENT:
return EMPTY_CURRENT_DECL;
@Override
protected final SubmoduleStatement createDeclared(final StmtContext<UnqualifiedQName, SubmoduleStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new SubmoduleStatementImpl(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new SubmoduleStatementImpl(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
final Collection<StmtContext<QName, BaseStatement, ?>> baseStatements =
StmtContextUtils.findAllDeclaredSubstatements(stmt, BaseStatement.class);
for (StmtContext<QName, BaseStatement, ?> baseStmt : baseStatements) {
- final QName baseIdentity = baseStmt.coerceStatementArgument();
+ final QName baseIdentity = baseStmt.getArgument();
final StmtContext<?, ?, ?> stmtCtx = stmt.getFromNamespace(IdentityNamespace.class, baseIdentity);
InferenceException.throwIfNull(stmtCtx, stmt.sourceReference(),
"Referenced base identity '%s' doesn't exist in given scope (module, imported modules, submodules)",
}
static @Nullable TypeStatement lookup(final StmtContext<String, TypeStatement, ?> ctx) {
- return BUILTINS.get(ctx.coerceStatementArgument());
+ return BUILTINS.get(ctx.getArgument());
}
}
// 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.coerceStatementArgument(), stmt);
+ parent.addContext(TypeNamespace.class, stmt.getArgument(), stmt);
}
}
}
protected TypedefStatement createDeclared(final StmtContext<QName, TypedefStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
checkDeclared(ctx);
- return new RegularTypedefStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularTypedefStatement(ctx.getArgument(), substatements);
}
@Override
protected TypedefStatement createEmptyDeclared(final StmtContext<QName, TypedefStatement, ?> ctx) {
checkDeclared(ctx);
- return new EmptyTypedefStatement(ctx.coerceStatementArgument());
+ return new EmptyTypedefStatement(ctx.getArgument());
}
@Override
}
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
- final QName arg = stmt.coerceStatementArgument();
+ final QName arg = stmt.getArgument();
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.sourceReference(), "Duplicate name for typedef %s", arg);
@Override
protected UniqueStatement createDeclared(final StmtContext<Set<Descendant>, UniqueStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularUniqueStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(),
- substatements);
+ return new RegularUniqueStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected UniqueStatement createEmptyDeclared(final StmtContext<Set<Descendant>, UniqueStatement, ?> ctx) {
- return new EmptyUniqueStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyUniqueStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected UsesStatement createDeclared(final StmtContext<QName, UsesStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularUsesStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularUsesStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected UsesStatement createEmptyDeclared(final StmtContext<QName, UsesStatement, ?> ctx) {
- return new EmptyUsesStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyUsesStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected WhenStatement createDeclared(final StmtContext<QualifiedBound, WhenStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularWhenStatement(ctx.getRawArgument(), ctx.coerceStatementArgument(), substatements);
+ return new RegularWhenStatement(ctx.getRawArgument(), ctx.getArgument(), substatements);
}
@Override
protected WhenStatement createEmptyDeclared(final StmtContext<QualifiedBound, WhenStatement, ?> ctx) {
- return new EmptyWhenStatement(ctx.getRawArgument(), ctx.coerceStatementArgument());
+ return new EmptyWhenStatement(ctx.getRawArgument(), ctx.getArgument());
}
@Override
@Override
protected YangVersionStatement createDeclared(final StmtContext<YangVersion, YangVersionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularYangVersionStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularYangVersionStatement(ctx.getArgument(), substatements);
}
@Override
protected YangVersionStatement createEmptyDeclared(final StmtContext<YangVersion, YangVersionStatement, ?> ctx) {
- final YangVersion argument = ctx.coerceStatementArgument();
+ final YangVersion argument = ctx.getArgument();
switch (argument) {
case VERSION_1:
return EMPTY_VER1_DECL;
@Override
protected YinElementStatement createDeclared(final StmtContext<Boolean, YinElementStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new RegularYinElementStatement(ctx.coerceStatementArgument(), substatements);
+ return new RegularYinElementStatement(ctx.getArgument(), substatements);
}
@Override
*
* @return raw statement argument string
* @throws VerifyException if this statement does not have an argument
+ * @deprecated Use {@link #getArgument()} instead.
*/
- // TODO: gradually migrate callers of this method
+ @Deprecated(forRemoval = true)
default @NonNull A coerceStatementArgument() {
return getArgument();
}
return stmt.allSubstatementsStream()
.filter(ctx -> ctx.isSupportedToBuildEffective() && ctx.producesEffective(type))
.findAny()
- .map(ctx -> (A) ctx.coerceStatementArgument());
+ .map(ctx -> (A) ctx.getArgument());
}
/**
if (YangStmtMapping.IF_FEATURE.equals(stmt.publicDefinition())) {
containsIfFeature = true;
@SuppressWarnings("unchecked")
- final Predicate<Set<QName>> argument = (Predicate<Set<QName>>) stmt.coerceStatementArgument();
+ final Predicate<Set<QName>> argument = (Predicate<Set<QName>>) stmt.getArgument();
if (argument.test(supportedFeatures)) {
isSupported = true;
} else {
private static boolean isListKey(final StmtContext<?, ?, ?> leafStmtCtx,
final StmtContext<Set<QName>, ?, ?> keyStmtCtx) {
- return keyStmtCtx.coerceStatementArgument().contains(leafStmtCtx.argument());
+ return keyStmtCtx.getArgument().contains(leafStmtCtx.argument());
}
private static void disallowIfFeatureAndWhenOnListKeys(final StmtContext<?, ?, ?> leafStmtCtx) {
Code Review / yangtools.git / commitdiff