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=bea54a8217a2c50d510ee20b45419dab65e62583;hb=387d6385bbd6a689372c6ac9cdde4021a7162e4d;hp=5a92e31c6eb1cc645a049a9c17829d9df65342b3;hpb=26267c3c9b4bd4e4ead26d7373ae1c1752876bde;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 5a92e31c6e..bea54a8217 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 @@ -8,71 +8,39 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import com.google.common.collect.ImmutableList.Builder; +import com.google.common.collect.ImmutableSet; import java.util.Collection; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedList; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Set; -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.meta.StatementDefinition; -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.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.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 String REGEX_PATH_REL1 = "\\.\\.?\\s*/(.+)"; - private static final String REGEX_PATH_REL2 = "//.*"; - private AugmentUtils() { } - 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); - } - - 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); } - public static void copyDeclaredStmts(StatementContextBase sourceCtx, - StatementContextBase targetCtx) throws SourceException { + // FIXME: Declared statements should not be copied. + private static void copyDeclaredStmts(final StatementContextBase sourceCtx, + final StatementContextBase targetCtx) throws SourceException { - Collection> declaredSubStatements = sourceCtx.declaredSubstatements(); - final List subStatements = new Builder() + final List> subStatements = new Builder>() .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals( Utils.getRootModuleQName(targetCtx)); @@ -80,7 +48,7 @@ public final class AugmentUtils { TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass() .equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION; - for (StatementContextBase originalStmtCtx : declaredSubStatements) { + for (StatementContextBase originalStmtCtx : sourceCtx.declaredSubstatements()) { if (needToCopyByAugment(originalStmtCtx)) { validateNodeCanBeCopiedByAugment(originalStmtCtx, subStatements, sourceAndTargetInSameModule); @@ -92,11 +60,10 @@ public final class AugmentUtils { } } - public static void copyEffectiveStmts(StatementContextBase sourceCtx, - StatementContextBase targetCtx) throws SourceException { + private static void copyEffectiveStmts(final StatementContextBase sourceCtx, + final StatementContextBase targetCtx) throws SourceException { - Collection> effectiveSubstatements = sourceCtx.effectiveSubstatements(); - final List subStatements = new Builder() + final List> subStatements = new Builder>() .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals( Utils.getRootModuleQName(targetCtx)); @@ -104,7 +71,7 @@ public final class AugmentUtils { TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass() .equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION; - for (StatementContextBase originalStmtCtx : effectiveSubstatements) { + for (StatementContextBase originalStmtCtx : sourceCtx.effectiveSubstatements()) { if (needToCopyByAugment(originalStmtCtx)) { validateNodeCanBeCopiedByAugment(originalStmtCtx, subStatements, sourceAndTargetInSameModule); @@ -117,17 +84,17 @@ public final class AugmentUtils { } private static void validateNodeCanBeCopiedByAugment(final StatementContextBase sourceCtx, - final List targetSubStatements, boolean sourceAndTargetInSameModule) { + final List> targetSubStatements, final boolean sourceAndTargetInSameModule) { if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) { return; } if (!sourceAndTargetInSameModule) { - final List sourceSubStatements = new Builder() + final List> sourceSubStatements = new Builder>() .addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build(); - for (final StatementContextBase sourceSubStatement : sourceSubStatements) { + for (final StatementContextBase sourceSubStatement : sourceSubStatements) { if (sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass() .equals(MandatoryStatement.class)) { throw new IllegalArgumentException( @@ -138,7 +105,7 @@ public final class AugmentUtils { } } - for (final StatementContextBase subStatement : targetSubStatements) { + for (final StatementContextBase subStatement : targetSubStatements) { final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx .getPublicDefinition().getDeclaredRepresentationClass()); @@ -155,152 +122,19 @@ public final class AugmentUtils { } } - public static QNameModule getNewQNameModule(StatementContextBase targetCtx, - 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; - } else { - return targetQNameModule; - } - } else { - return null; - } - } - - public static boolean needToCopyByAugment(StmtContext stmtContext) { - - Set noCopyDefSet = new HashSet<>(); - noCopyDefSet.add(Rfc6020Mapping.USES); + private static final Set NOCOPY_DEV_SET = ImmutableSet.of(Rfc6020Mapping.USES); - StatementDefinition def = stmtContext.getPublicDefinition(); - return !noCopyDefSet.contains(def); + public static boolean needToCopyByAugment(final StmtContext stmtContext) { + return !NOCOPY_DEV_SET.contains(stmtContext.getPublicDefinition()); } - public static boolean isReusedByAugment(StmtContext stmtContext) { - - Set reusedDefSet = new HashSet<>(); - reusedDefSet.add(Rfc6020Mapping.TYPEDEF); - - StatementDefinition def = stmtContext.getPublicDefinition(); + private static final Set REUSED_DEF_SET = ImmutableSet.of(Rfc6020Mapping.TYPEDEF); - return reusedDefSet.contains(def); + public static boolean isReusedByAugment(final StmtContext stmtContext) { + return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition()); } - public static StatementContextBase getAugmentTargetCtx( - final Mutable> augmentNode) { - - final SchemaNodeIdentifier augmentTargetNode = augmentNode.getStatementArgument(); - if (augmentTargetNode == null) { - throw new IllegalArgumentException( - "Augment argument null, something bad happened in some of previous parsing phases"); - } - - List> rootStatementCtxList = new LinkedList<>(); - 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(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(StatementContextBase parent, - QName nextPathQName) { - - Collection> declaredSubstatement = parent.declaredSubstatements(); - Collection> effectiveSubstatement = parent.effectiveSubstatements(); - - Collection> allSubstatements = new LinkedList<>(); - allSubstatements.addAll(declaredSubstatement); - allSubstatements.addAll(effectiveSubstatement); - - for (StatementContextBase substatement : allSubstatements) { - Object substatementArgument = substatement.getStatementArgument(); - QName substatementQName; - if (substatementArgument instanceof QName) { - substatementQName = (QName) substatementArgument; - - if (isSupportedAugmentTarget(substatement) - && nextPathQName.getLocalName().equals(substatementQName.getLocalName())) { - return substatement; - } - } // augment to extension - else if (StmtContextUtils.producesDeclared(substatement, UnknownStatementImpl.class) - && substatementArgument instanceof String) { - - final String nextPathName = nextPathQName.getLocalName(); - - if (nextPathName.equals(substatementArgument) - || nextPathName.equals(substatement.getPublicDefinition().getStatementName().getLocalName())) { - String message = "Module '" + substatement.getRoot().getStatementArgument() - + "': augment into extension '" + substatementArgument + "'."; - LOG.warn(message); - return substatement; - } - } - } - - return null; - } - - public static boolean isSupportedAugmentTarget(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 @@ -316,10 +150,4 @@ public final class AugmentUtils { return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty() || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition()); } - - @Nullable - public static StatementContextBase findCtxOfNodeInRoot(StatementContextBase rootStmtCtx, - final SchemaNodeIdentifier node) { - return findCtxOfNodeInSubstatements(rootStmtCtx, node.getPathFromRoot()); - } }