X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Frfc6020%2FAugmentUtils.java;h=9bcedcb22ba870bcc39e483e09da1346247017fb;hb=78cbd44f2617ed955064036b94f88603bc3de826;hp=dd14bf87d90860cd2ea415a833ad71e8c254064d;hpb=f6e95705ab22346ccdc6e5b84e5c0b14cd45511f;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentUtils.java index dd14bf87d9..9bcedcb22b 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentUtils.java @@ -7,81 +7,49 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import com.google.common.base.Preconditions; +import com.google.common.base.Verify; import com.google.common.collect.ImmutableList.Builder; import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Iterables; -import java.util.ArrayList; import java.util.Collection; -import java.util.Iterator; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Set; -import java.util.regex.Pattern; -import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; -import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement; import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement; -import org.opendaylight.yangtools.yang.parser.spi.NamespaceToModule; +import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; -import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace; import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType; +import org.opendaylight.yangtools.yang.parser.stmt.reactor.RootStatementContext; import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +// FIXME: Move this to the AugmentStatementDefinition#ApplyAction public final class AugmentUtils { - - private static final Logger LOG = LoggerFactory.getLogger(AugmentUtils.class); - private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)"); - private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*"); - private AugmentUtils() { - throw new UnsupportedOperationException(); - } - - public static Iterable parseAugmentPath(final StmtContext ctx, final String path) { - Preconditions.checkArgument(!PATH_REL_PATTERN1.matcher(path).matches() - && !PATH_REL_PATTERN2.matcher(path).matches(), - "An argument for augment can be only absolute path; or descendant if used in uses"); - - return Utils.parseXPath(ctx, path); } public static void copyFromSourceToTarget(final StatementContextBase sourceCtx, final StatementContextBase targetCtx) throws SourceException { - copyDeclaredStmts(sourceCtx, targetCtx); copyEffectiveStmts(sourceCtx, targetCtx); } - public static void copyDeclaredStmts(final StatementContextBase sourceCtx, + // FIXME: Declared statements should not be copied. + private static void copyDeclaredStmts(final StatementContextBase sourceCtx, final StatementContextBase targetCtx) throws SourceException { - final List> subStatements = new Builder>() - .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); - boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals( - Utils.getRootModuleQName(targetCtx)); - TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass() .equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION; for (StatementContextBase originalStmtCtx : sourceCtx.declaredSubstatements()) { if (needToCopyByAugment(originalStmtCtx)) { - validateNodeCanBeCopiedByAugment(originalStmtCtx, subStatements, sourceAndTargetInSameModule); + validateNodeCanBeCopiedByAugment(originalStmtCtx, targetCtx); StatementContextBase copy = originalStmtCtx.createCopy(targetCtx, typeOfCopy); targetCtx.addEffectiveSubstatement(copy); @@ -91,20 +59,14 @@ public final class AugmentUtils { } } - public static void copyEffectiveStmts(final StatementContextBase sourceCtx, + private static void copyEffectiveStmts(final StatementContextBase sourceCtx, final StatementContextBase targetCtx) throws SourceException { - - final List> subStatements = new Builder>() - .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); - boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals( - Utils.getRootModuleQName(targetCtx)); - TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass() .equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION; for (StatementContextBase originalStmtCtx : sourceCtx.effectiveSubstatements()) { if (needToCopyByAugment(originalStmtCtx)) { - validateNodeCanBeCopiedByAugment(originalStmtCtx, subStatements, sourceAndTargetInSameModule); + validateNodeCanBeCopiedByAugment(originalStmtCtx, targetCtx); StatementContextBase copy = originalStmtCtx.createCopy(targetCtx, typeOfCopy); targetCtx.addEffectiveSubstatement(copy); @@ -115,61 +77,89 @@ public final class AugmentUtils { } private static void validateNodeCanBeCopiedByAugment(final StatementContextBase sourceCtx, - final Iterable> targetSubStatements, - final boolean sourceAndTargetInSameModule) { + final StatementContextBase targetCtx) { - if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) { + if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) { return; } - if (!sourceAndTargetInSameModule) { - for (final StatementContextBase sourceSubStatement : - Iterables.concat(sourceCtx.declaredSubstatements(), sourceCtx.effectiveSubstatements())) { - Preconditions.checkArgument(!MandatoryStatement.class.equals( + if (reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) { + final List> sourceSubStatements = new Builder>() + .addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build(); + + for (final StatementContextBase sourceSubStatement : sourceSubStatements) { + InferenceException.throwIf(MandatoryStatement.class.equals( sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass()), + sourceCtx.getStatementSourceReference(), "An augment cannot add node '%s' because it is mandatory and in module different from target", sourceCtx.rawStatementArgument()); } } + final List> targetSubStatements = new Builder>() + .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); + for (final StatementContextBase subStatement : targetSubStatements) { - final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom( - sourceCtx.getPublicDefinition().getDeclaredRepresentationClass()); - final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom( - subStatement.getPublicDefinition().getDeclaredRepresentationClass()); - Preconditions.checkState(!sourceIsDataNode || !targetIsDataNode - || !Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument()), + final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx + .getPublicDefinition().getDeclaredRepresentationClass()); + final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement + .getPublicDefinition().getDeclaredRepresentationClass()); + boolean qNamesEqual = sourceIsDataNode && targetIsDataNode + && Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument()); + + InferenceException.throwIf(qNamesEqual, sourceCtx.getStatementSourceReference(), "An augment cannot add node named '%s' because this name is already used in target", sourceCtx.rawStatementArgument()); } } - public static QNameModule getNewQNameModule(final StatementContextBase targetCtx, - final StatementContextBase sourceCtx) { - Object targetStmtArgument = targetCtx.getStatementArgument(); - - final StatementContextBase root = sourceCtx.getRoot(); - final QNameModule sourceQNameModule = root.getFromNamespace(ModuleCtxToModuleQName.class, root); - - if (targetStmtArgument instanceof QName) { - QName targetQName = (QName) targetStmtArgument; - QNameModule targetQNameModule = targetQName.getModule(); - - if (targetQNameModule.equals(sourceQNameModule)) { - return null; + private static boolean reguiredCheckOfMandatoryNodes(StatementContextBase sourceCtx, + StatementContextBase targetCtx) { + /* + * If the statement argument is not QName, it cannot be mandatory statement, + * therefore return false and skip mandatory nodes validation + */ + if(!(sourceCtx.getStatementArgument() instanceof QName)) { + return false; + } + QName sourceStmtQName = (QName) sourceCtx.getStatementArgument(); + + RootStatementContext root = targetCtx.getRoot(); + do { + Verify.verify(targetCtx.getStatementArgument() instanceof QName, + "Argument of augment target statement must be QName."); + QName targetStmtQName = (QName) targetCtx.getStatementArgument(); + /* + * If target is from another module, return true and perform + * mandatory nodes validation + */ + if (!Utils.belongsToTheSameModule(targetStmtQName, sourceStmtQName)) { + return true; } else { - return targetQNameModule; + /* + * If target or one of its parent is a presence container from + * the same module, return false and skip mandatory nodes + * validation + */ + if (Utils.isPresenceContainer(targetCtx)) { + return false; + } } - } else { - return null; - } + } while ((targetCtx = targetCtx.getParentContext()) != root); + + /* + * All target node's parents belong to the same module as source node, + * therefore return false and skip mandatory nodes validation. + */ + return false; } - private static final Set NOCOPY_DEV_SET = ImmutableSet.of(Rfc6020Mapping.USES); + private static final Set NOCOPY_DEF_SET = ImmutableSet.of(Rfc6020Mapping.USES, Rfc6020Mapping.WHEN, + Rfc6020Mapping.DESCRIPTION, Rfc6020Mapping.REFERENCE, Rfc6020Mapping.STATUS); public static boolean needToCopyByAugment(final StmtContext stmtContext) { - return !NOCOPY_DEV_SET.contains(stmtContext.getPublicDefinition()); + return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition()); } private static final Set REUSED_DEF_SET = ImmutableSet.of(Rfc6020Mapping.TYPEDEF); @@ -178,103 +168,10 @@ public final class AugmentUtils { return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition()); } - public static StatementContextBase getAugmentTargetCtx( - final Mutable> augmentNode) { - - final SchemaNodeIdentifier augmentTargetNode = augmentNode.getStatementArgument(); - Preconditions.checkArgument(augmentTargetNode != null, - "Augment argument null, something bad happened in some of previous parsing phases"); - - List> rootStatementCtxList = new ArrayList<>(); - if (augmentTargetNode.isAbsolute()) { - - QNameModule module = augmentTargetNode.getPathFromRoot().iterator().next().getModule(); - - StatementContextBase rootStatementCtx = - (StatementContextBase) augmentNode.getFromNamespace(NamespaceToModule.class, module); - rootStatementCtxList.add(rootStatementCtx); - - final Map subModules = rootStatementCtx.getAllFromNamespace(IncludedModuleContext.class); - if (subModules != null) { - rootStatementCtxList.addAll((Collection>) subModules.values()); - } - - } else { - StatementContextBase parent = (StatementContextBase) augmentNode.getParentContext(); - if (StmtContextUtils.producesDeclared(parent, UsesStatement.class)) { - rootStatementCtxList.add(parent.getParentContext()); - } else { - // error - } - } - - StatementContextBase augmentTargetCtx = null; - for (final StatementContextBase rootStatementCtx : rootStatementCtxList) { - augmentTargetCtx = findCtxOfNodeInRoot(rootStatementCtx, augmentTargetNode); - if (augmentTargetCtx != null) { - break; - } - } - - return augmentTargetCtx; - } - - @Nullable - public static StatementContextBase findCtxOfNodeInSubstatements(final StatementContextBase rootStmtCtx, - final Iterable path) { - - StatementContextBase parent = rootStmtCtx; - - Iterator pathIter = path.iterator(); - while (pathIter.hasNext()) { - QName nextPathQName = pathIter.next(); - StatementContextBase foundSubstatement = getSubstatementByQName(parent, nextPathQName); - - if (foundSubstatement == null) { - return null; - } - if (!pathIter.hasNext()) { - return foundSubstatement; - } - - parent = foundSubstatement; - } - - return null; - } - - public static StatementContextBase getSubstatementByQName(final StatementContextBase parent, - final QName nextPathQName) { - - Collection> declaredSubstatement = parent.declaredSubstatements(); - Collection> effectiveSubstatement = parent.effectiveSubstatements(); - - for (StatementContextBase substatement : Iterables.concat(declaredSubstatement, effectiveSubstatement)) { - Object substatementArgument = substatement.getStatementArgument(); - QName substatementQName; - if (substatementArgument instanceof QName) { - substatementQName = (QName) substatementArgument; - - if (nextPathQName.getLocalName().equals( - substatementQName.getLocalName())) { - if (isSupportedAugmentTarget(substatement)) { - return substatement; - } else if (Utils.isUnknownNode(substatement)) { - LOG.warn("Module '{}': augment into unknown node '{}'.", - substatement.getRoot().getStatementArgument(), substatementArgument); - return substatement; - } - } - } - } - - return null; - } - - public static boolean isSupportedAugmentTarget(final StatementContextBase substatementCtx) { + static boolean isSupportedAugmentTarget(final StatementContextBase substatementCtx) { /* - * :TODO Substatement must be allowed augment target type e.g. Container, etc... and must be not for example + * :TODO Substatement must be allowed augment target type e.g. Container, etc... and must not be for example * grouping, identity etc. It is problem in case when more than one substatements have the same QName, for * example Grouping and Container are siblings and they have the same QName. We must find the Container and the * Grouping must be ignored as disallowed augment target. @@ -287,10 +184,4 @@ public final class AugmentUtils { return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty() || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition()); } - - @Nullable - public static StatementContextBase findCtxOfNodeInRoot(final StatementContextBase rootStmtCtx, - final SchemaNodeIdentifier node) { - return findCtxOfNodeInSubstatements(rootStmtCtx, node.getPathFromRoot()); - } }