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=66cfd1d51ed332f91a9446f4c67e415195d55bfa;hpb=4078c52f76ce904726f0e127eba1a96c7bae357d;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 66cfd1d51e..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 @@ -1,59 +1,57 @@ /** * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - *

+ * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; +import com.google.common.base.Verify; +import com.google.common.collect.ImmutableList.Builder; +import com.google.common.collect.ImmutableSet; import java.util.Collection; -import java.util.HashSet; - +import java.util.List; +import java.util.Objects; +import java.util.Set; 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.meta.StatementDefinition; -import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; -import org.opendaylight.yangtools.yang.parser.spi.NamespaceToModule; +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.UsesStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement; +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.source.ModuleNameToModuleQName; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy; 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; -public class AugmentUtils { - - private static final String REGEX_PATH_REL1 = "\\.\\.?\\s*/(.+)"; - private static final String REGEX_PATH_REL2 = "//.*"; - - public static Iterable parseAugmentPath(StmtContext ctx, String path) { - - if (path.matches(REGEX_PATH_REL1) || path.matches(REGEX_PATH_REL2)) { - throw new IllegalArgumentException( - "An argument for augment can be only absolute path; or descendant if used in uses"); - } - - return Utils.parseXPath(ctx, path); +// FIXME: Move this to the AugmentStatementDefinition#ApplyAction +public final class AugmentUtils { + private AugmentUtils() { } - public static void copyFromSourceToTarget(StatementContextBase sourceCtx, - StatementContextBase targetCtx) throws SourceException { + public static void copyFromSourceToTarget(final StatementContextBase sourceCtx, + final StatementContextBase targetCtx) throws SourceException { + copyDeclaredStmts(sourceCtx, targetCtx); + copyEffectiveStmts(sourceCtx, targetCtx); + } - QNameModule newQNameModule = getNewQNameModule(targetCtx, sourceCtx); - copyDeclaredStmts(sourceCtx, targetCtx, newQNameModule); - copyEffectiveStmts(sourceCtx, targetCtx, newQNameModule); + // FIXME: Declared statements should not be copied. + private static void copyDeclaredStmts(final StatementContextBase sourceCtx, + final StatementContextBase targetCtx) throws SourceException { - } + TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass() + .equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION; - public static void copyDeclaredStmts(StatementContextBase sourceCtx, - StatementContextBase targetCtx, QNameModule newQNameModule) throws SourceException { - Collection> declaredSubstatements = sourceCtx.declaredSubstatements(); - for (StatementContextBase originalStmtCtx : declaredSubstatements) { + for (StatementContextBase originalStmtCtx : sourceCtx.declaredSubstatements()) { if (needToCopyByAugment(originalStmtCtx)) { - StatementContextBase copy = originalStmtCtx.createCopy(newQNameModule, targetCtx); + validateNodeCanBeCopiedByAugment(originalStmtCtx, targetCtx); + + StatementContextBase copy = originalStmtCtx.createCopy(targetCtx, typeOfCopy); targetCtx.addEffectiveSubstatement(copy); } else if (isReusedByAugment(originalStmtCtx)) { targetCtx.addEffectiveSubstatement(originalStmtCtx); @@ -61,12 +59,16 @@ public class AugmentUtils { } } - public static void copyEffectiveStmts(StatementContextBase sourceCtx, - StatementContextBase targetCtx, QNameModule newQNameModule) throws SourceException { - Collection> effectiveSubstatements = sourceCtx.effectiveSubstatements(); - for (StatementContextBase originalStmtCtx : effectiveSubstatements) { + private static void copyEffectiveStmts(final StatementContextBase sourceCtx, + final StatementContextBase targetCtx) throws SourceException { + 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)) { - StatementContextBase copy = originalStmtCtx.createCopy(newQNameModule, targetCtx); + validateNodeCanBeCopiedByAugment(originalStmtCtx, targetCtx); + + StatementContextBase copy = originalStmtCtx.createCopy(targetCtx, typeOfCopy); targetCtx.addEffectiveSubstatement(copy); } else if (isReusedByAugment(originalStmtCtx)) { targetCtx.addEffectiveSubstatement(originalStmtCtx); @@ -74,77 +76,112 @@ public class AugmentUtils { } } - public static QNameModule getNewQNameModule(StatementContextBase targetCtx, - StatementContextBase sourceCtx) { - Object targetStmtArgument = targetCtx.getStatementArgument(); + private static void validateNodeCanBeCopiedByAugment(final StatementContextBase sourceCtx, + final StatementContextBase targetCtx) { - final StatementContextBase root = sourceCtx.getRoot(); - final String moduleName = (String) root.getStatementArgument(); - final QNameModule sourceQNameModule = root.getFromNamespace(ModuleNameToModuleQName.class, moduleName); - - if (targetStmtArgument instanceof QName) { - QName targetQName = (QName) targetStmtArgument; - QNameModule targetQNameModule = targetQName.getModule(); + if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) { + return; + } - if (targetQNameModule.equals(sourceQNameModule)) - return null; - else - return targetQNameModule; - } else - return null; - } + if (reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) { + final List> sourceSubStatements = new Builder>() + .addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build(); - public static boolean needToCopyByAugment(StmtContext stmtContext) { + 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()); + } + } - HashSet noCopyDefSet = new HashSet<>(); - noCopyDefSet.add(Rfc6020Mapping.USES); + final List> targetSubStatements = new Builder>() + .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); - StatementDefinition def = stmtContext.getPublicDefinition(); - if (noCopyDefSet.contains(def)) - return false; - else - return true; - } + for (final StatementContextBase subStatement : targetSubStatements) { - public static boolean isReusedByAugment(StmtContext stmtContext) { + 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()); - HashSet reusedDefSet = new HashSet<>(); - reusedDefSet.add(Rfc6020Mapping.TYPEDEF); + InferenceException.throwIf(qNamesEqual, sourceCtx.getStatementSourceReference(), + "An augment cannot add node named '%s' because this name is already used in target", + sourceCtx.rawStatementArgument()); + } + } - StatementDefinition def = stmtContext.getPublicDefinition(); - if (reusedDefSet.contains(def)) - return true; - else + 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 { + /* + * 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; + } + } + } while ((targetCtx = targetCtx.getParentContext()) != root); - public static StatementContextBase getAugmentTargetCtx( - final Mutable> augmentNode) { + /* + * All target node's parents belong to the same module as source node, + * therefore return false and skip mandatory nodes validation. + */ + return false; + } - final SchemaNodeIdentifier augmentTargetPath = augmentNode.getStatementArgument(); + private static final Set NOCOPY_DEF_SET = ImmutableSet.of(Rfc6020Mapping.USES, Rfc6020Mapping.WHEN, + Rfc6020Mapping.DESCRIPTION, Rfc6020Mapping.REFERENCE, Rfc6020Mapping.STATUS); - QNameModule module; - if (augmentTargetPath != null) { - module = augmentTargetPath.getPathFromRoot().iterator().next().getModule(); - } else { - throw new IllegalArgumentException( - "Augment argument null, something bad happened in some of previous parsing phases"); - } + public static boolean needToCopyByAugment(final StmtContext stmtContext) { + return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition()); + } - StatementContextBase rootStatementCtx = (StatementContextBase) augmentNode.getFromNamespace( - NamespaceToModule.class, module); + private static final Set REUSED_DEF_SET = ImmutableSet.of(Rfc6020Mapping.TYPEDEF); - final StatementContextBase augmentTargetCtx = Utils.findCtxOfNodeInRoot(rootStatementCtx, - augmentTargetPath); + public static boolean isReusedByAugment(final StmtContext stmtContext) { + return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition()); + } - if (augmentTargetCtx == null) { + static boolean isSupportedAugmentTarget(final StatementContextBase substatementCtx) { - throw new NullPointerException(String.format( - "Augment path %s not found in target model so its resulting context is null", - augmentNode.rawStatementArgument())); + /* + * :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. + */ - } + Collection allowedAugmentTargets = substatementCtx.getFromNamespace(ValidationBundlesNamespace.class, + ValidationBundleType.SUPPORTED_AUGMENT_TARGETS); - return augmentTargetCtx; + // if no allowed target is returned we consider all targets allowed + return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty() + || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition()); } }