From 95c6962044a966e200315a68dca9d541c7a1a019 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Fri, 27 Nov 2020 05:35:55 +0100 Subject: [PATCH] Migrate get{PublicDefinition,StatementSource} callers This is a mass migration of callers, deprecating the two methods in the process. Change-Id: Ia7b49a57269eecf5751d669a3fd31dad68b07cb1 Signed-off-by: Robert Varga --- .../reactor/AbstractResumedStatement.java | 8 ++--- .../reactor/InferredStatementContext.java | 2 +- .../stmt/reactor/StatementContextBase.java | 10 +++--- .../stmt/reactor/StatementContextWriter.java | 4 +-- .../parser/rfc7950/stmt/ArgumentUtils.java | 2 +- .../AbstractAugmentStatementSupport.java | 19 +++++------ .../AugmentStatementRFC7950Support.java | 2 +- .../case_/AbstractCaseStatementSupport.java | 8 ++--- .../AbstractDeviateStatementSupport.java | 34 +++++++++---------- .../UnrecognizedStatementSupport.java | 2 +- .../input/AbstractInputStatementSupport.java | 8 ++--- .../AbstractOutputStatementSupport.java | 8 ++--- .../stmt/uses/UsesStatementSupport.java | 14 ++++---- .../spi/meta/AbstractDeclaredStatement.java | 6 ++-- .../yang/parser/spi/meta/StmtContext.java | 4 +-- .../parser/spi/meta/StmtContextUtils.java | 25 +++++++------- .../spi/meta/SubstatementValidator.java | 2 +- 17 files changed, 78 insertions(+), 80 deletions(-) diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java index f8a3a5b734..8a92906875 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java @@ -134,13 +134,13 @@ abstract class AbstractResumedStatement, E ext } @Override - public @NonNull StatementDefinition getDefinition() { - return getPublicDefinition(); + public StatementDefinition getDefinition() { + return publicDefinition(); } @Override - public @NonNull StatementSourceReference getSourceReference() { - return getStatementSourceReference(); + public StatementSourceReference getSourceReference() { + return sourceReference(); } @Override diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java index fafcd61bba..c6e3034064 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java @@ -315,7 +315,7 @@ final class InferredStatementContext, E extend private void copySubstatement(final Mutable substatement, final Collection> buffer, final Map, StatementContextBase> materializedSchemaTree) { - final StatementDefinition def = substatement.getPublicDefinition(); + final StatementDefinition def = substatement.publicDefinition(); // FIXME: YANGTOOLS-652: formerly known as "isReusedByUses" if (REUSED_DEF_SET.contains(def)) { diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java index 070d890957..4f72b2d9d5 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java @@ -383,7 +383,7 @@ public abstract class StatementContextBase, E final Iterator> iterator = effective.iterator(); while (iterator.hasNext()) { final StmtContext next = iterator.next(); - if (statementDef.equals(next.getPublicDefinition())) { + if (statementDef.equals(next.publicDefinition())) { iterator.remove(); } } @@ -420,7 +420,7 @@ public abstract class StatementContextBase, E final Iterator> iterator = effective.iterator(); while (iterator.hasNext()) { final Mutable next = iterator.next(); - if (statementDef.equals(next.getPublicDefinition()) && statementArg.equals(next.rawStatementArgument())) { + if (statementDef.equals(next.publicDefinition()) && statementArg.equals(next.rawStatementArgument())) { iterator.remove(); } } @@ -874,7 +874,7 @@ public abstract class StatementContextBase, E private , Z extends EffectiveStatement> Mutable childCopyOf( final StatementContextBase original, final CopyType type, final QNameModule targetModule) { final Optional> implicitParent = definition.getImplicitParentFor( - original.getPublicDefinition()); + original.publicDefinition()); final StatementContextBase result; final InferredStatementContext copy; @@ -922,7 +922,7 @@ public abstract class StatementContextBase, E @Beta public final StatementContextBase wrapWithImplicit(final StatementContextBase original) { final Optional> optImplicit = definition.getImplicitParentFor( - original.getPublicDefinition()); + original.publicDefinition()); if (optImplicit.isEmpty()) { return original; } @@ -1060,7 +1060,7 @@ public abstract class StatementContextBase, E final SchemaPath parentPath = maybeParentPath.get(); if (StmtContextUtils.isUnknownStatement(this)) { - return parentPath.createChild(getPublicDefinition().getStatementName()); + return parentPath.createChild(publicDefinition().getStatementName()); } final Object argument = getStatementArgument(); if (argument instanceof QName) { diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java index c0ef1180af..6f29dff5f9 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java @@ -88,7 +88,7 @@ final class StatementContextWriter implements StatementWriter { // - allow endDeclared() to be moved to AbstractResumedStatement // - remove the need for verify() StatementContextBase parentContext = current.getParentContext(); - while (parentContext != null && StatementSource.CONTEXT == parentContext.getStatementSource()) { + while (parentContext != null && StatementSource.CONTEXT == parentContext.source()) { parentContext.endDeclared(phase); parentContext = parentContext.getParentContext(); } @@ -108,7 +108,7 @@ final class StatementContextWriter implements StatementWriter { // Fast path: we are entering a statement which was emitted in previous phase AbstractResumedStatement existing = current.lookupSubstatement(childId); - while (existing != null && StatementSource.CONTEXT == existing.getStatementSource()) { + while (existing != null && StatementSource.CONTEXT == existing.source()) { existing = existing.lookupSubstatement(childId); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ArgumentUtils.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ArgumentUtils.java index 5ed39e3975..8c1210b703 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ArgumentUtils.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ArgumentUtils.java @@ -69,7 +69,7 @@ public final class ArgumentUtils { } else if ("false".equals(input)) { return Boolean.FALSE; } else { - final StatementDefinition def = ctx.getPublicDefinition(); + final StatementDefinition def = ctx.publicDefinition(); throw new SourceException(ctx.getStatementSourceReference(), "Invalid '%s' statement %s '%s', it can be either 'true' or 'false'", def.getStatementName(), def.getArgumentDefinition().get().getArgumentName(), input); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AbstractAugmentStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AbstractAugmentStatementSupport.java index f94f7b2f19..31e1218c0c 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AbstractAugmentStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AbstractAugmentStatementSupport.java @@ -129,8 +129,8 @@ abstract class AbstractAugmentStatementSupport /* * Do not fail, if it is an uses-augment to an unknown node. */ - if (YangStmtMapping.USES == augmentNode.coerceParentContext().getPublicDefinition()) { - final SchemaNodeIdentifier augmentArg = augmentNode.coerceStatementArgument(); + if (YangStmtMapping.USES == augmentNode.coerceParentContext().publicDefinition()) { + final SchemaNodeIdentifier augmentArg = augmentNode.getArgument(); final Optional> targetNode = SchemaTreeNamespace.findNode( getSearchRoot(augmentNode), augmentArg); if (targetNode.isPresent() && StmtContextUtils.isUnknownStatement(targetNode.get())) { @@ -150,14 +150,13 @@ abstract class AbstractAugmentStatementSupport @Override protected final AugmentStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return new RegularAugmentStatement(ctx.coerceRawStatementArgument(), ctx.coerceStatementArgument(), - substatements); + return new RegularAugmentStatement(ctx.getRawArgument(), ctx.getArgument(), substatements); } @Override protected final AugmentStatement createEmptyDeclared( final StmtContext ctx) { - return new EmptyAugmentStatement(ctx.coerceRawStatementArgument(), ctx.coerceStatementArgument()); + return new EmptyAugmentStatement(ctx.getRawArgument(), ctx.getArgument()); } @Override @@ -190,7 +189,7 @@ abstract class AbstractAugmentStatementSupport private static StmtContext getSearchRoot(final StmtContext augmentContext) { // Augment is in uses - we need to augment instantiated nodes in parent. final StmtContext parent = augmentContext.coerceParentContext(); - if (YangStmtMapping.USES == parent.getPublicDefinition()) { + if (YangStmtMapping.USES == parent.publicDefinition()) { return parent.getParentContext(); } return parent; @@ -352,7 +351,7 @@ abstract class AbstractAugmentStatementSupport private static StmtContext getParentAugmentation(final StmtContext child) { StmtContext parent = Verify.verifyNotNull(child.getParentContext(), "Child %s has not parent", child); - while (parent.getPublicDefinition() != YangStmtMapping.AUGMENT) { + while (parent.publicDefinition() != YangStmtMapping.AUGMENT) { parent = Verify.verifyNotNull(parent.getParentContext(), "Failed to find augmentation parent of %s", child); } return parent; @@ -362,13 +361,13 @@ abstract class AbstractAugmentStatementSupport YangStmtMapping.WHEN, YangStmtMapping.DESCRIPTION, YangStmtMapping.REFERENCE, YangStmtMapping.STATUS); private static boolean needToCopyByAugment(final StmtContext stmtContext) { - return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition()); + return !NOCOPY_DEF_SET.contains(stmtContext.publicDefinition()); } private static final ImmutableSet REUSED_DEF_SET = ImmutableSet.of(YangStmtMapping.TYPEDEF); private static boolean isReusedByAugment(final StmtContext stmtContext) { - return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition()); + return REUSED_DEF_SET.contains(stmtContext.publicDefinition()); } static boolean isSupportedAugmentTarget(final StmtContext substatementCtx) { @@ -385,6 +384,6 @@ abstract class AbstractAugmentStatementSupport // if no allowed target is returned we consider all targets allowed return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty() - || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition()); + || allowedAugmentTargets.contains(substatementCtx.publicDefinition()); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AugmentStatementRFC7950Support.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AugmentStatementRFC7950Support.java index d59f18c42b..2d397c7e64 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AugmentStatementRFC7950Support.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/augment/AugmentStatementRFC7950Support.java @@ -53,6 +53,6 @@ public final class AugmentStatementRFC7950Support extends AbstractAugmentStateme @Override boolean allowsMandatory(final StmtContext ctx) { - return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT && hasWhenSubstatement(ctx); + return ctx.publicDefinition() == YangStmtMapping.AUGMENT && hasWhenSubstatement(ctx); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java index 7bf6f5a987..f1f4081595 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java @@ -33,8 +33,8 @@ abstract class AbstractCaseStatementSupport @Override protected final CaseStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - final StatementSource source = ctx.getStatementSource(); - switch (ctx.getStatementSource()) { + final StatementSource source = ctx.source(); + switch (source) { case CONTEXT: return new RegularUndeclaredCaseStatement(ctx.coerceStatementArgument(), substatements); case DECLARATION: @@ -46,8 +46,8 @@ abstract class AbstractCaseStatementSupport @Override protected final CaseStatement createEmptyDeclared(final StmtContext ctx) { - final StatementSource source = ctx.getStatementSource(); - switch (ctx.getStatementSource()) { + final StatementSource source = ctx.source(); + switch (source) { case CONTEXT: return new EmptyUndeclaredCaseStatement(ctx.coerceStatementArgument()); case DECLARATION: diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/deviate/AbstractDeviateStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/deviate/AbstractDeviateStatementSupport.java index ef13375a5a..08e609a674 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/deviate/AbstractDeviateStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/deviate/AbstractDeviateStatementSupport.java @@ -256,11 +256,11 @@ abstract class AbstractDeviateStatementSupport private static void addStatement(final Mutable stmtCtxToBeAdded, final StatementContextBase targetCtx) { if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeAdded)) { - final StatementDefinition stmtToBeAdded = stmtCtxToBeAdded.getPublicDefinition(); + final StatementDefinition stmtToBeAdded = stmtCtxToBeAdded.publicDefinition(); if (SINGLETON_STATEMENTS.contains(stmtToBeAdded) || YangStmtMapping.DEFAULT.equals(stmtToBeAdded) - && YangStmtMapping.LEAF.equals(targetCtx.getPublicDefinition())) { + && YangStmtMapping.LEAF.equals(targetCtx.publicDefinition())) { for (final StmtContext targetCtxSubstatement : targetCtx.allSubstatements()) { - InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.getPublicDefinition()), + InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.publicDefinition()), stmtCtxToBeAdded.getStatementSourceReference(), "Deviation cannot add substatement %s to target node %s because it is already defined " + "in target and can appear only once.", @@ -284,10 +284,10 @@ abstract class AbstractDeviateStatementSupport private static void replaceStatement(final Mutable stmtCtxToBeReplaced, final StatementContextBase targetCtx) { - final StatementDefinition stmtToBeReplaced = stmtCtxToBeReplaced.getPublicDefinition(); + final StatementDefinition stmtToBeReplaced = stmtCtxToBeReplaced.publicDefinition(); if (YangStmtMapping.DEFAULT.equals(stmtToBeReplaced) - && YangStmtMapping.LEAF_LIST.equals(targetCtx.getPublicDefinition())) { + && YangStmtMapping.LEAF_LIST.equals(targetCtx.publicDefinition())) { LOG.error("Deviation cannot replace substatement {} in target leaf-list {} because a leaf-list can " + "have multiple default statements. At line: {}", stmtToBeReplaced.getStatementName(), targetCtx.getStatementArgument(), stmtCtxToBeReplaced.getStatementSourceReference()); @@ -295,7 +295,7 @@ abstract class AbstractDeviateStatementSupport } for (final StmtContext targetCtxSubstatement : targetCtx.effectiveSubstatements()) { - if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) { + if (stmtToBeReplaced.equals(targetCtxSubstatement.publicDefinition())) { targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeReplaced); copyStatement(stmtCtxToBeReplaced, targetCtx); return; @@ -303,7 +303,7 @@ abstract class AbstractDeviateStatementSupport } for (final Mutable targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) { - if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) { + if (stmtToBeReplaced.equals(targetCtxSubstatement.publicDefinition())) { targetCtxSubstatement.setIsSupportedToBuildEffective(false); copyStatement(stmtCtxToBeReplaced, targetCtx); return; @@ -335,20 +335,20 @@ abstract class AbstractDeviateStatementSupport private static void deleteStatement(final StmtContext stmtCtxToBeDeleted, final StatementContextBase targetCtx) { - final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition(); - final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument(); + final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.publicDefinition(); + final String stmtArgument = stmtCtxToBeDeleted.rawArgument(); for (final Mutable targetCtxSubstatement : targetCtx.mutableEffectiveSubstatements()) { - if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(), - targetCtxSubstatement.rawStatementArgument())) { + if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.publicDefinition(), + targetCtxSubstatement.rawArgument())) { targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeDeleted, stmtArgument); return; } } for (final Mutable targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) { - if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(), - targetCtxSubstatement.rawStatementArgument())) { + if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.publicDefinition(), + targetCtxSubstatement.rawArgument())) { targetCtxSubstatement.setIsSupportedToBuildEffective(false); return; } @@ -380,22 +380,22 @@ abstract class AbstractDeviateStatementSupport InferenceException.throwIf(!isSupportedDeviationTarget(deviateSubStmtCtx, targetCtx, targetCtx.getRootVersion()), deviateSubStmtCtx.getStatementSourceReference(), "%s is not a valid deviation target for substatement %s.", - targetCtx.getStatementArgument(), deviateSubStmtCtx.getPublicDefinition().getStatementName()); + targetCtx.getStatementArgument(), deviateSubStmtCtx.publicDefinition().getStatementName()); } private static boolean isSupportedDeviationTarget(final StmtContext deviateSubstatementCtx, final StmtContext deviateTargetCtx, final YangVersion yangVersion) { Set supportedDeviationTargets = YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(deviateTargetCtx.getRootVersion(), - deviateSubstatementCtx.getPublicDefinition()); + deviateSubstatementCtx.publicDefinition()); if (supportedDeviationTargets == null) { supportedDeviationTargets = YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(YangVersion.VERSION_1, - deviateSubstatementCtx.getPublicDefinition()); + deviateSubstatementCtx.publicDefinition()); } // if supportedDeviationTargets is null, it means that the deviate substatement is an unknown statement return supportedDeviationTargets == null || supportedDeviationTargets.contains( - deviateTargetCtx.getPublicDefinition()); + deviateTargetCtx.publicDefinition()); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/UnrecognizedStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/UnrecognizedStatementSupport.java index 5bd4d620c4..2a7dec913e 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/UnrecognizedStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/UnrecognizedStatementSupport.java @@ -58,7 +58,7 @@ final class UnrecognizedStatementSupport @Override protected UnrecognizedStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return new UnrecognizedStatementImpl(ctx.rawStatementArgument(), ctx.getPublicDefinition(), substatements); + return new UnrecognizedStatementImpl(ctx.rawStatementArgument(), ctx.publicDefinition(), substatements); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java index 32f58c9098..b756f1d06f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java @@ -29,8 +29,8 @@ abstract class AbstractInputStatementSupport @Override protected final InputStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - final StatementSource source = ctx.getStatementSource(); - switch (ctx.getStatementSource()) { + final StatementSource source = ctx.source(); + switch (source) { case CONTEXT: return new RegularUndeclaredInputStatement(ctx.coerceStatementArgument(), substatements); case DECLARATION: @@ -42,8 +42,8 @@ abstract class AbstractInputStatementSupport @Override protected final InputStatement createEmptyDeclared(final StmtContext ctx) { - final StatementSource source = ctx.getStatementSource(); - switch (ctx.getStatementSource()) { + final StatementSource source = ctx.source(); + switch (source) { case CONTEXT: return new EmptyUndeclaredInputStatement(ctx.coerceStatementArgument()); case DECLARATION: diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java index d988358a25..8f368bf856 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java @@ -29,8 +29,8 @@ abstract class AbstractOutputStatementSupport @Override protected final OutputStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - final StatementSource source = ctx.getStatementSource(); - switch (ctx.getStatementSource()) { + final StatementSource source = ctx.source(); + switch (source) { case CONTEXT: return new RegularUndeclaredOutputStatement(ctx.coerceStatementArgument(), substatements); case DECLARATION: @@ -42,8 +42,8 @@ abstract class AbstractOutputStatementSupport @Override protected final OutputStatement createEmptyDeclared(final StmtContext ctx) { - final StatementSource source = ctx.getStatementSource(); - switch (ctx.getStatementSource()) { + final StatementSource source = ctx.source(); + switch (source) { case CONTEXT: return new EmptyUndeclaredOutputStatement(ctx.coerceStatementArgument()); case DECLARATION: diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java index 2c57a0da4c..96dac6261b 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java @@ -229,7 +229,7 @@ public final class UsesStatementSupport // This means that the statement that is about to be copied (and can be subjected to buildEffective() I think) // is actually a SchemaTreeEffectiveStatement if (SchemaTreeEffectiveStatement.class.isAssignableFrom( - stmt.getPublicDefinition().getEffectiveRepresentationClass())) { + stmt.publicDefinition().getEffectiveRepresentationClass())) { return true; } @@ -260,7 +260,7 @@ public final class UsesStatementSupport if (targetCtx.getParentContext() == null) { return targetCtx.getFromNamespace(ModuleCtxToModuleQName.class, targetCtx); } - if (targetCtx.getPublicDefinition() == YangStmtMapping.AUGMENT) { + if (targetCtx.publicDefinition() == YangStmtMapping.AUGMENT) { return StmtContextUtils.getRootModuleQName(targetCtx); } @@ -329,14 +329,14 @@ public final class UsesStatementSupport private static void addOrReplaceNode(final Mutable refineSubstatementCtx, final StatementContextBase refineTargetNodeCtx) { - final StatementDefinition refineSubstatementDef = refineSubstatementCtx.getPublicDefinition(); + final StatementDefinition refineSubstatementDef = refineSubstatementCtx.publicDefinition(); 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().rawStatementArgument(), refineSubstatementCtx.coerceParentContext().getStatementArgument(), - refineSubstatementCtx.getPublicDefinition(), refineTargetNodeCtx.getPublicDefinition()); + refineSubstatementCtx.publicDefinition(), refineTargetNodeCtx.publicDefinition()); if (isAllowedToAddByRefine(refineSubstatementDef)) { refineTargetNodeCtx.addEffectiveSubstatement(refineSubstatementCtx); @@ -355,16 +355,16 @@ public final class UsesStatementSupport ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_REFINE_SUBSTATEMENTS); return supportedRefineSubstatements == null || supportedRefineSubstatements.isEmpty() - || supportedRefineSubstatements.contains(refineSubstatementCtx.getPublicDefinition()) + || supportedRefineSubstatements.contains(refineSubstatementCtx.publicDefinition()) || StmtContextUtils.isUnknownStatement(refineSubstatementCtx); } private static boolean isSupportedRefineTarget(final StmtContext refineSubstatementCtx, final StmtContext refineTargetNodeCtx) { final Collection supportedRefineTargets = YangValidationBundles.SUPPORTED_REFINE_TARGETS.get( - refineSubstatementCtx.getPublicDefinition()); + refineSubstatementCtx.publicDefinition()); return supportedRefineTargets == null || supportedRefineTargets.isEmpty() - || supportedRefineTargets.contains(refineTargetNodeCtx.getPublicDefinition()); + || supportedRefineTargets.contains(refineTargetNodeCtx.publicDefinition()); } } diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java index d150ab98a9..1db723c641 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java @@ -31,9 +31,9 @@ public abstract class AbstractDeclaredStatement implements DeclaredStatement< protected AbstractDeclaredStatement(final StmtContext context) { rawArgument = context.rawStatementArgument(); - argument = context.getStatementArgument(); - source = context.getStatementSource(); - definition = context.getPublicDefinition(); + argument = context.argument(); + source = context.source(); + definition = context.publicDefinition(); /* * Perform an explicit copy, because Collections2.transform() is lazily transformed and retains pointer to * original collection, which may contains references to mutable context. diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java index 2f1b2f5814..b9372e0fc0 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java @@ -38,12 +38,12 @@ import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReferenc */ public interface StmtContext, E extends EffectiveStatement> extends BoundStmtCtx { - // TODO: gradually migrate callers of this method + @Deprecated(forRemoval = true) default @NonNull StatementDefinition getPublicDefinition() { return publicDefinition(); } - // TODO: gradually migrate callers of this method + @Deprecated(forRemoval = true) default @NonNull StatementSource getStatementSource() { return source(); } diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java index c6ca59509e..1262a3e6ab 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java @@ -222,8 +222,7 @@ public final class StmtContextUtils { * if supplied statement context is null */ public static boolean isUnknownStatement(final StmtContext stmtCtx) { - return UnknownStatement.class - .isAssignableFrom(stmtCtx.getPublicDefinition().getDeclaredRepresentationClass()); + return UnknownStatement.class.isAssignableFrom(stmtCtx.publicDefinition().getDeclaredRepresentationClass()); } /** @@ -246,7 +245,7 @@ public final class StmtContextUtils { boolean isSupported = false; boolean containsIfFeature = false; for (final StmtContext stmt : stmtContext.declaredSubstatements()) { - if (YangStmtMapping.IF_FEATURE.equals(stmt.getPublicDefinition())) { + if (YangStmtMapping.IF_FEATURE.equals(stmt.publicDefinition())) { containsIfFeature = true; @SuppressWarnings("unchecked") final Predicate> argument = (Predicate>) stmt.coerceStatementArgument(); @@ -270,7 +269,7 @@ public final class StmtContextUtils { * @return true if it is a presence container */ public static boolean isPresenceContainer(final StmtContext stmtCtx) { - return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && containsPresenceSubStmt(stmtCtx); + return stmtCtx.publicDefinition() == YangStmtMapping.CONTAINER && containsPresenceSubStmt(stmtCtx); } /** @@ -281,7 +280,7 @@ public final class StmtContextUtils { * @return true if it is a non-presence container */ public static boolean isNonPresenceContainer(final StmtContext stmtCtx) { - return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && !containsPresenceSubStmt(stmtCtx); + return stmtCtx.publicDefinition() == YangStmtMapping.CONTAINER && !containsPresenceSubStmt(stmtCtx); } private static boolean containsPresenceSubStmt(final StmtContext stmtCtx) { @@ -298,10 +297,10 @@ public final class StmtContextUtils { * according to RFC6020. */ public static boolean isMandatoryNode(final StmtContext stmtCtx) { - if (!(stmtCtx.getPublicDefinition() instanceof YangStmtMapping)) { + if (!(stmtCtx.publicDefinition() instanceof YangStmtMapping)) { return false; } - switch ((YangStmtMapping) stmtCtx.getPublicDefinition()) { + switch ((YangStmtMapping) stmtCtx.publicDefinition()) { case LEAF: case CHOICE: case ANYXML: @@ -330,7 +329,7 @@ public final class StmtContextUtils { */ public static boolean isNotMandatoryNodeOfType(final StmtContext stmtCtx, final StatementDefinition stmtDef) { - return stmtCtx.getPublicDefinition().equals(stmtDef) && !isMandatoryNode(stmtCtx); + return stmtCtx.publicDefinition().equals(stmtDef) && !isMandatoryNode(stmtCtx); } /** @@ -406,7 +405,7 @@ public final class StmtContextUtils { public static boolean hasParentOfType(final StmtContext ctx, final StatementDefinition parentType) { requireNonNull(parentType); final StmtContext parentContext = ctx.getParentContext(); - return parentContext != null && parentType.equals(parentContext.getPublicDefinition()); + return parentContext != null && parentType.equals(parentContext.publicDefinition()); } /** @@ -427,11 +426,11 @@ public final class StmtContextUtils { final StmtContext listStmtCtx = ctx.coerceParentContext(); final StmtContext, ?, ?> keyStmtCtx = findFirstDeclaredSubstatement(listStmtCtx, KeyStatement.class); - if (YangStmtMapping.LEAF.equals(ctx.getPublicDefinition())) { + if (YangStmtMapping.LEAF.equals(ctx.publicDefinition())) { if (isListKey(ctx, keyStmtCtx)) { disallowIfFeatureAndWhenOnListKeys(ctx); } - } else if (YangStmtMapping.USES.equals(ctx.getPublicDefinition())) { + } else if (YangStmtMapping.USES.equals(ctx.publicDefinition())) { findAllEffectiveSubstatements(listStmtCtx, LeafStatement.class).forEach(leafStmtCtx -> { if (isListKey(leafStmtCtx, keyStmtCtx)) { disallowIfFeatureAndWhenOnListKeys(leafStmtCtx); @@ -452,7 +451,7 @@ public final class StmtContextUtils { private static void disallowIfFeatureAndWhenOnListKeys(final StmtContext leafStmtCtx) { leafStmtCtx.allSubstatements().forEach(leafSubstmtCtx -> { - final StatementDefinition statementDef = leafSubstmtCtx.getPublicDefinition(); + final StatementDefinition statementDef = leafSubstmtCtx.publicDefinition(); SourceException.throwIf(YangStmtMapping.IF_FEATURE.equals(statementDef) || YangStmtMapping.WHEN.equals(statementDef), leafStmtCtx.getStatementSourceReference(), "%s statement is not allowed in %s leaf statement which is specified as a list key.", @@ -462,7 +461,7 @@ public final class StmtContextUtils { public static QName qnameFromArgument(StmtContext ctx, final String value) { if (Strings.isNullOrEmpty(value)) { - return ctx.getPublicDefinition().getStatementName(); + return ctx.publicDefinition().getStatementName(); } String prefix; diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/SubstatementValidator.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/SubstatementValidator.java index b0e3764a0b..df38887232 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/SubstatementValidator.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/SubstatementValidator.java @@ -114,7 +114,7 @@ public final class SubstatementValidator { final Map stmtCounts = new HashMap<>(); for (StmtContext stmtCtx : ctx.allSubstatements()) { - stmtCounts.computeIfAbsent(stmtCtx.getPublicDefinition(), key -> new Counter()).increment(); + stmtCounts.computeIfAbsent(stmtCtx.publicDefinition(), key -> new Counter()).increment(); } // Mark all mandatory statements as not present. We are using a Map instead of a Set, as it provides us with -- 2.36.6