X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-rfc7950%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Frfc7950%2Fstmt%2Fdeviate%2FAbstractDeviateStatementSupport.java;h=219e46bb974115fe2a9e430032a204f2991178f4;hb=refs%2Fchanges%2F88%2F94088%2F7;hp=fe87e9411d7c4f6234afffb5aa7f03ec0a2a9989;hpb=1a630f8ab35e5550ac8019f8cbf2bc5e82fd1f78;p=yangtools.git 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 fe87e9411d..219e46bb97 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 @@ -7,8 +7,10 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; import com.google.common.collect.Maps; import com.google.common.collect.SetMultimap; import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; @@ -20,14 +22,22 @@ import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.common.YangVersion; import org.opendaylight.yangtools.yang.model.api.DeviateKind; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.DeviateEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; -import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace; +import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration; +import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators; +import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles; +import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction; @@ -46,8 +56,8 @@ import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport> { +abstract class AbstractDeviateStatementSupport + extends AbstractStatementSupport { private static final Logger LOG = LoggerFactory.getLogger(AbstractDeviateStatementSupport.class); private static final SubstatementValidator DEVIATE_NOT_SUPPORTED_SUBSTATEMENT_VALIDATOR = @@ -94,36 +104,24 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< private static final ImmutableSet IMPLICIT_STATEMENTS = ImmutableSet.of(YangStmtMapping.CONFIG, YangStmtMapping.MANDATORY, YangStmtMapping.MAX_ELEMENTS, YangStmtMapping.MIN_ELEMENTS); - AbstractDeviateStatementSupport() { - super(YangStmtMapping.DEVIATE); + AbstractDeviateStatementSupport(final YangParserConfiguration config) { + super(YangStmtMapping.DEVIATE, StatementPolicy.contextIndependent(), config); } @Override public final DeviateKind parseArgumentValue(final StmtContext ctx, final String value) { - return SourceException.throwIfNull(KEYWORD_TO_DEVIATE_MAP.get(value), - ctx.getStatementSourceReference(), "String '%s' is not valid deviate argument", value); + return SourceException.throwIfNull(KEYWORD_TO_DEVIATE_MAP.get(value), ctx, + "String '%s' is not valid deviate argument", value); } @Override - public final DeviateStatement createDeclared(final StmtContext ctx) { - return new DeviateStatementImpl(ctx); - } - - @Override - public final EffectiveStatement createEffective( - final StmtContext> ctx) { - return new DeviateEffectiveStatementImpl(ctx); - } - - @Override - public final void onFullDefinitionDeclared(final Mutable> deviateStmtCtx) { - final DeviateKind deviateKind = deviateStmtCtx.getStatementArgument(); + public final void onFullDefinitionDeclared( + final Mutable deviateStmtCtx) { + final DeviateKind deviateKind = deviateStmtCtx.argument(); getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx); final SchemaNodeIdentifier deviationTarget = - (SchemaNodeIdentifier) deviateStmtCtx.coerceParentContext().getStatementArgument(); + (SchemaNodeIdentifier) deviateStmtCtx.coerceParentContext().argument(); if (!isDeviationSupported(deviateStmtCtx, deviationTarget)) { return; @@ -132,13 +130,13 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< final ModelActionBuilder deviateAction = deviateStmtCtx.newInferenceAction( ModelProcessingPhase.EFFECTIVE_MODEL); - final Prerequisite>> sourceCtxPrerequisite = + final Prerequisite> sourceCtxPrerequisite = deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL); final Prerequisite>> targetCtxPrerequisite = deviateAction.mutatesEffectiveCtxPath(deviateStmtCtx.getRoot(), - ChildSchemaNodeNamespace.class, deviationTarget.getPathFromRoot()); + SchemaTreeNamespace.class, deviationTarget.getNodeIdentifiers()); deviateAction.apply(new InferenceAction() { @Override @@ -169,8 +167,8 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< @Override public void prerequisiteFailed(final Collection> failed) { - throw new InferenceException(deviateStmtCtx.coerceParentContext().getStatementSourceReference(), - "Deviation target '%s' not found.", deviationTarget); + throw new InferenceException(deviateStmtCtx.coerceParentContext(), "Deviation target '%s' not found.", + deviationTarget); } }); } @@ -195,6 +193,24 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< return null; } + @Override + protected final DeviateStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return DeclaredStatements.createDeviate(ctx.getArgument(), substatements); + } + + @Override + protected final DeviateStatement attachDeclarationReference(final DeviateStatement stmt, + final DeclarationReference reference) { + return DeclaredStatementDecorators.decorateDeviate(stmt, reference); + } + + @Override + protected final DeviateEffectiveStatement createEffective(final Current stmt, + final ImmutableList> substatements) { + return EffectiveStatements.createDeviate(stmt.declared(), substatements); + } + protected SubstatementValidator getSubstatementValidatorForDeviate(final DeviateKind deviateKind) { switch (deviateKind) { case NOT_SUPPORTED: @@ -211,8 +227,8 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< } } - private static boolean isDeviationSupported(final Mutable> deviateStmtCtx, + private static boolean isDeviationSupported( + final Mutable deviateStmtCtx, final SchemaNodeIdentifier deviationTarget) { final SetMultimap modulesDeviatedByModules = deviateStmtCtx.getFromNamespace( ModulesDeviatedByModules.class, SupportedModules.SUPPORTED_MODULES); @@ -222,7 +238,7 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< final QNameModule currentModule = deviateStmtCtx.getFromNamespace(ModuleCtxToModuleQName.class, deviateStmtCtx.getRoot()); - final QNameModule targetModule = deviationTarget.getLastComponent().getModule(); + final QNameModule targetModule = Iterables.getLast(deviationTarget.getNodeIdentifiers()).getModule(); final Set deviationModulesSupportedByTargetModule = modulesDeviatedByModules.get(targetModule); if (deviationModulesSupportedByTargetModule != null) { @@ -245,15 +261,15 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< 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()), - stmtCtxToBeAdded.getStatementSourceReference(), + InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.publicDefinition()), + stmtCtxToBeAdded, "Deviation cannot add substatement %s to target node %s because it is already defined " + "in target and can appear only once.", - stmtToBeAdded.getStatementName(), targetCtx.getStatementArgument()); + stmtToBeAdded.getStatementName(), targetCtx.argument()); } } } @@ -273,18 +289,18 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< 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()); + targetCtx.argument(), stmtCtxToBeReplaced.sourceReference()); return; } for (final StmtContext targetCtxSubstatement : targetCtx.effectiveSubstatements()) { - if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) { + if (stmtToBeReplaced.equals(targetCtxSubstatement.publicDefinition())) { targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeReplaced); copyStatement(stmtCtxToBeReplaced, targetCtx); return; @@ -292,7 +308,7 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< } for (final Mutable targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) { - if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) { + if (stmtToBeReplaced.equals(targetCtxSubstatement.publicDefinition())) { targetCtxSubstatement.setIsSupportedToBuildEffective(false); copyStatement(stmtCtxToBeReplaced, targetCtx); return; @@ -307,9 +323,9 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< return; } - throw new InferenceException(stmtCtxToBeReplaced.getStatementSourceReference(), "Deviation cannot replace " - + "substatement %s in target node %s because it does not exist in target node.", - stmtToBeReplaced.getStatementName(), targetCtx.getStatementArgument()); + throw new InferenceException(stmtCtxToBeReplaced, + "Deviation cannot replace substatement %s in target node %s because it does not exist in target node.", + stmtToBeReplaced.getStatementName(), targetCtx.argument()); } @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD", @@ -324,20 +340,20 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< 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; } @@ -345,7 +361,7 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< LOG.error("Deviation cannot delete substatement {} with argument '{}' in target node {} because it does " + "not exist in the target node. At line: {}", stmtToBeDeleted.getStatementName(), stmtArgument, - targetCtx.getStatementArgument(), stmtCtxToBeDeleted.getStatementSourceReference()); + targetCtx.argument(), stmtCtxToBeDeleted.sourceReference()); } private static void copyStatement(final Mutable stmtCtxToBeCopied, @@ -353,7 +369,7 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< // we need to make a copy of the statement context only if it is an unknown statement, otherwise // we can reuse the original statement context if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeCopied)) { - targetCtx.addEffectiveSubstatement(stmtCtxToBeCopied); + targetCtx.addEffectiveSubstatement(stmtCtxToBeCopied.replicaAsChildOf(targetCtx)); } else { targetCtx.addEffectiveSubstatement(targetCtx.childCopyOf(stmtCtxToBeCopied, CopyType.ORIGINAL)); } @@ -367,24 +383,24 @@ abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport< private static void validateDeviationTarget(final StmtContext deviateSubStmtCtx, final StmtContext targetCtx) { 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.yangVersion()), deviateSubStmtCtx, + "%s is not a valid deviation target for substatement %s.", targetCtx.argument(), + 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()); + YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(yangVersion, + 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()); } }