From: Robert Varga Date: Fri, 18 Sep 2015 09:39:42 +0000 (+0200) Subject: Cleanup AugmentUtils X-Git-Tag: release/beryllium~237 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=10cca853ec377e18e8978df38cc3c5d71bec7f3c;p=yangtools.git Cleanup AugmentUtils Du no copy collections, user preconditions, use pre-instantiated sets and similar. Change-Id: I1fadd465650323504515e3df9393d42c8593c1e8 Signed-off-by: Robert Varga --- 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 984a862ad1..dd14bf87d9 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,21 +7,23 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; +import com.google.common.base.Preconditions; 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.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 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.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; @@ -44,19 +46,17 @@ import org.slf4j.LoggerFactory; 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 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) { - - 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"); - } + 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); } @@ -71,7 +71,6 @@ public final class AugmentUtils { public static void copyDeclaredStmts(final StatementContextBase sourceCtx, final StatementContextBase targetCtx) throws SourceException { - Collection> declaredSubStatements = sourceCtx.declaredSubstatements(); final List> subStatements = new Builder>() .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals( @@ -80,7 +79,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); @@ -95,7 +94,6 @@ public final class AugmentUtils { public static void copyEffectiveStmts(final StatementContextBase sourceCtx, final StatementContextBase targetCtx) throws SourceException { - Collection> effectiveSubstatements = sourceCtx.effectiveSubstatements(); final List> subStatements = new Builder>() .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals( @@ -104,7 +102,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,41 +115,33 @@ public final class AugmentUtils { } private static void validateNodeCanBeCopiedByAugment(final StatementContextBase sourceCtx, - final List> targetSubStatements, final boolean sourceAndTargetInSameModule) { + final Iterable> targetSubStatements, + final boolean sourceAndTargetInSameModule) { - if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) { + if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) { return; } if (!sourceAndTargetInSameModule) { - final List> sourceSubStatements = new Builder>() - .addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build(); - - for (final StatementContextBase sourceSubStatement : sourceSubStatements) { - if (sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass() - .equals(MandatoryStatement.class)) { - throw new IllegalArgumentException( - String.format( - "An augment cannot add node '%s' because it is mandatory and in module different from target", - sourceCtx.rawStatementArgument())); - } + for (final StatementContextBase sourceSubStatement : + Iterables.concat(sourceCtx.declaredSubstatements(), sourceCtx.effectiveSubstatements())) { + Preconditions.checkArgument(!MandatoryStatement.class.equals( + sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass()), + "An augment cannot add node '%s' because it is mandatory and in module different from target", + sourceCtx.rawStatementArgument()); } } for (final StatementContextBase subStatement : targetSubStatements) { - 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()); - - if (qNamesEqual) { - throw new IllegalStateException(String.format( - "An augment cannot add node named '%s' because this name is already used in target", - sourceCtx.rawStatementArgument())); - } + 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()), + "An augment cannot add node named '%s' because this name is already used in target", + sourceCtx.rawStatementArgument()); } } @@ -176,41 +166,32 @@ public final class AugmentUtils { } } - public static boolean needToCopyByAugment(final 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(final 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"); - } + Preconditions.checkArgument(augmentTargetNode != null, + "Augment argument null, something bad happened in some of previous parsing phases"); - List> rootStatementCtxList = new LinkedList<>(); + List> rootStatementCtxList = new ArrayList<>(); if (augmentTargetNode.isAbsolute()) { QNameModule module = augmentTargetNode.getPathFromRoot().iterator().next().getModule(); - StatementContextBase rootStatementCtx = (StatementContextBase) augmentNode - .getFromNamespace(NamespaceToModule.class, module); + StatementContextBase rootStatementCtx = + (StatementContextBase) augmentNode.getFromNamespace(NamespaceToModule.class, module); rootStatementCtxList.add(rootStatementCtx); final Map subModules = rootStatementCtx.getAllFromNamespace(IncludedModuleContext.class); @@ -268,11 +249,7 @@ public final class AugmentUtils { Collection> declaredSubstatement = parent.declaredSubstatements(); Collection> effectiveSubstatement = parent.effectiveSubstatements(); - Collection> allSubstatements = new LinkedList<>(); - allSubstatements.addAll(declaredSubstatement); - allSubstatements.addAll(effectiveSubstatement); - - for (StatementContextBase substatement : allSubstatements) { + for (StatementContextBase substatement : Iterables.concat(declaredSubstatement, effectiveSubstatement)) { Object substatementArgument = substatement.getStatementArgument(); QName substatementQName; if (substatementArgument instanceof QName) { @@ -283,12 +260,8 @@ public final class AugmentUtils { if (isSupportedAugmentTarget(substatement)) { return substatement; } else if (Utils.isUnknownNode(substatement)) { - // augment into unknown node - String message = "Module '" - + substatement.getRoot().getStatementArgument() - + "': augment into unknown node '" - + substatementArgument + "'."; - LOG.warn(message); + LOG.warn("Module '{}': augment into unknown node '{}'.", + substatement.getRoot().getStatementArgument(), substatementArgument); return substatement; } }