From 04fa25a4fe8957f6492618aa9a1e9a4f9af39df4 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Tue, 5 Jan 2016 00:46:14 +0100 Subject: [PATCH] Introduce formatting methods for SourceException - throwIf() is similar to Preconditions.checkArgument(), but checks the inverse condition - throwIfNull() is similar to Preconditions.checkNotNull() - new constructors with string formatting - fix {Invalid,Missing}SubstatementException not having a version Change-Id: I95d15fb6a591f77b0be17d9ca50f51d3636c80ed Signed-off-by: Robert Varga (cherry picked from commit c652590993b1e4660d5d557868665dbfa634ed27) --- .../parser/impl/YinStatementParserImpl.java | 70 +++++++------- .../parser/spi/SubstatementValidator.java | 84 ++++++++--------- .../parser/spi/meta/InferenceException.java | 30 ++++-- .../meta/InvalidSubstatementException.java | 8 +- .../meta/MissingSubstatementException.java | 8 +- .../parser/spi/source/SourceException.java | 92 +++++++++++++++++-- .../stmt/reactor/SourceSpecificContext.java | 61 ++++++------ .../stmt/rfc6020/AugmentStatementImpl.java | 50 +++++----- .../parser/stmt/rfc6020/AugmentUtils.java | 20 ++-- .../stmt/rfc6020/BaseStatementImpl.java | 28 +++--- .../stmt/rfc6020/BelongsToStatementImpl.java | 45 +++++---- .../parser/stmt/rfc6020/GroupingUtils.java | 15 ++- .../rfc6020/ImportStatementDefinition.java | 35 ++++--- .../stmt/rfc6020/IncludeStatementImpl.java | 34 +++---- .../stmt/rfc6020/ModuleStatementSupport.java | 27 ++---- .../rfc6020/RevisionDateStatementImpl.java | 33 +++---- .../stmt/rfc6020/RevisionStatementImpl.java | 33 +++---- .../stmt/rfc6020/SubmoduleStatementImpl.java | 35 +++---- .../stmt/rfc6020/TypeStatementImpl.java | 17 +--- .../yang/parser/stmt/rfc6020/TypeUtils.java | 22 ++--- .../stmt/rfc6020/TypedefStatementImpl.java | 22 ++--- .../stmt/rfc6020/UsesStatementImpl.java | 13 +-- .../yang/parser/stmt/rfc6020/Utils.java | 3 +- ...tEffectiveDocumentedDataNodeContainer.java | 5 +- .../rfc6020/effective/EffectiveStmtUtils.java | 18 ++-- .../ImportEffectiveStatementImpl.java | 2 +- .../effective/LeafEffectiveStatementImpl.java | 7 +- .../LeafListEffectiveStatementImpl.java | 7 +- .../effective/ListEffectiveStatementImpl.java | 6 +- .../BinaryTypeEffectiveStatementImpl.java | 4 +- ...tsSpecificationEffectiveStatementImpl.java | 9 +- ...umSpecificationEffectiveStatementImpl.java | 4 +- .../IntegerTypeEffectiveStatementImpl.java | 4 +- .../StringTypeEffectiveStatementImpl.java | 4 +- .../stmt/retest/YangParserNegativeTest.java | 12 +-- 35 files changed, 441 insertions(+), 426 deletions(-) diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YinStatementParserImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YinStatementParserImpl.java index 4ce9bce649..5128185a22 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YinStatementParserImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YinStatementParserImpl.java @@ -37,17 +37,17 @@ public class YinStatementParserImpl { private static final Logger LOG = LoggerFactory.getLogger(YinStatementParserImpl.class); + private final List toBeSkipped = new ArrayList<>(); + private final String sourceName; private StatementWriter writer; private QNameToStatementDefinition stmtDef; private PrefixToModule prefixes; - private final String sourceName; private String uriStr; private boolean isType = false; private boolean action = true; private boolean yinElement = false; - private List toBeSkipped = new ArrayList<>(); - public YinStatementParserImpl(String sourceName) { + public YinStatementParserImpl(final String sourceName) { this.sourceName = Preconditions.checkNotNull(sourceName); } @@ -57,18 +57,16 @@ public class YinStatementParserImpl { * created. * When done, start walking through YIN source * - * * @param writer - instance of StatementWriter to emit declared statements * @param stmtDef - map of valid statement definitions for linkage phase * */ - public void setAttributes(StatementWriter writer, QNameToStatementDefinition stmtDef) { + public void setAttributes(final StatementWriter writer, final QNameToStatementDefinition stmtDef) { this.writer = writer; this.stmtDef = stmtDef; } /** - * * This method is supposed to be called in any phase but linkage, when YinStatementParserImpl instance has already * been created. * When done, start walking through YIN source @@ -78,20 +76,18 @@ public class YinStatementParserImpl { * @param prefixes - map of valid prefixes for any phase but linkage * */ - public void setAttributes(StatementWriter writer, QNameToStatementDefinition stmtDef, PrefixToModule prefixes) { + public void setAttributes(final StatementWriter writer, final QNameToStatementDefinition stmtDef, final PrefixToModule prefixes) { this.writer = writer; this.stmtDef = stmtDef; this.prefixes = prefixes; } /** - * * This method executes parsing YIN source and emitting declared statements via attached StatementWriter * * @param inputReader - instance of XMlStreamReader, allows forward, read-only access to XML. - * */ - public void walk(XMLStreamReader inputReader) { + public void walk(final XMLStreamReader inputReader) { try { while (inputReader.hasNext()) { inputReader.next(); @@ -110,11 +106,11 @@ public class YinStatementParserImpl { } } - private void startStatement(QName identifier, StatementSourceReference ref) { + private void startStatement(final QName identifier, final StatementSourceReference ref) { writer.startStatement(identifier, ref); } - private void argumentValue(XMLStreamReader inputReader, StatementSourceReference ref, QName identifier, boolean + private void argumentValue(final XMLStreamReader inputReader, final StatementSourceReference ref, final QName identifier, final boolean yinElement) { if (yinElement) { writeTextOnlyElement(inputReader, ref); @@ -123,11 +119,11 @@ public class YinStatementParserImpl { } } - private void endStatement(StatementSourceReference ref) { + private void endStatement(final StatementSourceReference ref) { writer.endStatement(ref); } - private void enterStatement(XMLStreamReader inputReader) throws URISyntaxException { + private void enterStatement(final XMLStreamReader inputReader) throws URISyntaxException { final StatementSourceReference ref = DeclarationInTextSource.atPosition(sourceName, inputReader .getLocation().getLineNumber(), inputReader.getLocation().getColumnNumber()); uriStr = inputReader.getNamespaceURI(); @@ -155,14 +151,12 @@ public class YinStatementParserImpl { } } else { //if statement not found through all phases, throw exception - if (writer.getPhase().equals(ModelProcessingPhase.FULL_DECLARATION)) { - throw new SourceException(String.format("%s is not a YIN statement or use of extension.", - identifier.getLocalName()), ref); - } else { - //otherwise skip it (statement not to be read yet) - action = false; - toBeSkipped.add(getElementFullName(inputReader)); - } + SourceException.throwIf(writer.getPhase().equals(ModelProcessingPhase.FULL_DECLARATION), ref, + "%s is not a YIN statement or use of extension.", identifier.getLocalName()); + + //otherwise skip it (statement not to be read yet) + action = false; + toBeSkipped.add(getElementFullName(inputReader)); } if (isType) { @@ -175,7 +169,7 @@ public class YinStatementParserImpl { } } - private void exitStatement(XMLStreamReader inputReader) throws URISyntaxException { + private void exitStatement(final XMLStreamReader inputReader) throws URISyntaxException { final String statementName = getElementFullName(inputReader); final QName identifier = new QName(new URI(inputReader.getNamespaceURI()), statementName); final StatementSourceReference ref = DeclarationInTextSource.atPosition(sourceName, inputReader @@ -196,7 +190,7 @@ public class YinStatementParserImpl { } } - private void writeTextOnlyElement(XMLStreamReader inputReader, StatementSourceReference ref) { + private void writeTextOnlyElement(final XMLStreamReader inputReader, final StatementSourceReference ref) { try { writer.argumentValue(inputReader.getElementText(), ref); } catch (XMLStreamException e) { @@ -204,14 +198,15 @@ public class YinStatementParserImpl { } } - private void writeNormalizedAttributeValue(XMLStreamReader inputReader, QName - identifier, StatementSourceReference ref) { + private void writeNormalizedAttributeValue(final XMLStreamReader inputReader, final QName + identifier, final StatementSourceReference ref) { final String attributeValue = getAttributeValue(inputReader, identifier, stmtDef); - if (attributeValue != null) + if (attributeValue != null) { writer.argumentValue(attributeValue, ref); + } } - private void writeTypeStmtAndArg(XMLStreamReader inputReader, QName identifier, StatementSourceReference ref) { + private void writeTypeStmtAndArg(final XMLStreamReader inputReader, final QName identifier, final StatementSourceReference ref) { String argument = getAttributeValue(inputReader, identifier, stmtDef); if (TypeUtils.isYangTypeBodyStmtString(argument)) { startStatement(new QName(YangConstants.RFC6020_YIN_NAMESPACE, argument), ref); @@ -223,7 +218,7 @@ public class YinStatementParserImpl { isType = false; } - private static String getElementFullName(XMLStreamReader inputReader) { + private static String getElementFullName(final XMLStreamReader inputReader) { if (!inputReader.getPrefix().isEmpty()) { return inputReader.getPrefix() + ":" + inputReader.getLocalName(); } else { @@ -231,29 +226,28 @@ public class YinStatementParserImpl { } } - private static boolean isStatementWithArgument(QName identifier, QNameToStatementDefinition stmtDef) { + private static boolean isStatementWithArgument(final QName identifier, final QNameToStatementDefinition stmtDef) { if (stmtDef != null && stmtDef.get(Utils.trimPrefix(identifier)) == null) { return false; - } else if (((StatementSupport) stmtDef.get(Utils.trimPrefix(identifier))) - .getPublicView().getArgumentName() == null) { + } else if (((StatementSupport) stmtDef.get(Utils.trimPrefix(identifier))).getPublicView().getArgumentName() == null) { return false; } return true; } - private static boolean isStatementWithYinElement(QName identifier, QNameToStatementDefinition stmtDef) { + private static boolean isStatementWithYinElement(final QName identifier, final QNameToStatementDefinition stmtDef) { final StatementDefinition statementDefinition = stmtDef.get(Utils.trimPrefix(identifier)); - if (statementDefinition != null) { - return ((Rfc6020Mapping) ((StatementSupport) statementDefinition).getPublicView()).isArgumentYinElement(); - } else { + if (statementDefinition == null) { return false; } + + return ((Rfc6020Mapping) ((StatementSupport) statementDefinition).getPublicView()).isArgumentYinElement(); } - private static String getAttributeValue(XMLStreamReader inputReader, QName identifier, QNameToStatementDefinition + private static String getAttributeValue(final XMLStreamReader inputReader, final QName identifier, final QNameToStatementDefinition stmtDef) { String namespace = null; - return inputReader.getAttributeValue(namespace, (((StatementSupport) stmtDef.get(Utils.trimPrefix(identifier))) + return inputReader.getAttributeValue(namespace, (((StatementSupport) stmtDef.get(Utils.trimPrefix(identifier))) .getPublicView()).getArgumentName().getLocalName()); } } \ No newline at end of file diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/SubstatementValidator.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/SubstatementValidator.java index 362fd04547..761b60c1f2 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/SubstatementValidator.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/SubstatementValidator.java @@ -8,34 +8,34 @@ package org.opendaylight.yangtools.yang.parser.spi; +import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Iterables; import com.google.common.collect.MapDifference; import com.google.common.collect.Maps; -import java.util.ArrayList; -import java.util.Collection; import java.util.HashMap; import java.util.Map; +import java.util.Map.Entry; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.parser.spi.meta.InvalidSubstatementException; import org.opendaylight.yangtools.yang.parser.spi.meta.MissingSubstatementException; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName; import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase; -import org.opendaylight.yangtools.yang.parser.util.YangParseException; public final class SubstatementValidator { + public final static int MAX = Integer.MAX_VALUE; private final Map cardinalityMap; private final StatementDefinition currentStatement; private final SpecialCase specialCase; - public final static int MAX = Integer.MAX_VALUE; - private SubstatementValidator(Builder builder, SpecialCase specialCase) { + private SubstatementValidator(final Builder builder, final SpecialCase specialCase) { this.cardinalityMap = builder.cardinalityMap.build(); this.currentStatement = builder.currentStatement; this.specialCase = specialCase; } - public static Builder builder(StatementDefinition currentStatement) { + public static Builder builder(final StatementDefinition currentStatement) { return new Builder(currentStatement); } @@ -43,11 +43,11 @@ public final class SubstatementValidator { private final ImmutableMap.Builder cardinalityMap = ImmutableMap.builder(); private final StatementDefinition currentStatement; - private Builder(StatementDefinition currentStatement) { + private Builder(final StatementDefinition currentStatement) { this.currentStatement = currentStatement; } - public Builder add(StatementDefinition d, int min, int max) { + public Builder add(final StatementDefinition d, final int min, final int max) { this.cardinalityMap.put(d, new Cardinality(min, max)); return this; } @@ -56,19 +56,17 @@ public final class SubstatementValidator { return new SubstatementValidator(this, SpecialCase.NULL); } - public SubstatementValidator build(SpecialCase specialCase) { + public SubstatementValidator build(final SpecialCase specialCase) { return new SubstatementValidator(this, specialCase); } } public void validate(final StmtContext ctx) throws InvalidSubstatementException, MissingSubstatementException { - final Map stmtDefMap = new HashMap<>(); - final Map validatedMap = new HashMap<>(); - final Collection> substatementsInit = new ArrayList<>(); - substatementsInit.addAll(ctx.declaredSubstatements()); - substatementsInit.addAll(ctx.effectiveSubstatements()); + final Iterable> substatementsInit = Iterables.concat( + ctx.declaredSubstatements(), ctx.effectiveSubstatements()); + final Map stmtDefMap = new HashMap<>(); for (StatementContextBase stmtCtx : substatementsInit) { final StatementDefinition definition = stmtCtx.getPublicDefinition(); if (!stmtDefMap.containsKey(definition)) { @@ -79,49 +77,47 @@ public final class SubstatementValidator { } if (stmtDefMap.isEmpty() && specialCase == SpecialCase.NOTNULL) { - throw new InvalidSubstatementException(String.format("%s must contain atleast 1 element. Error in module " - + "%s (%s)", currentStatement, ctx.getRoot().getStatementArgument(), - ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())), - ctx.getStatementSourceReference()); + throw new InvalidSubstatementException(ctx.getStatementSourceReference(), + "%s must contain atleast 1 element. Error in module %s (%s)", currentStatement, + ctx.getRoot().getStatementArgument(), + ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())); } - for (Map.Entry entry : stmtDefMap.entrySet()) { + final Map validatedMap = new HashMap<>(); + for (Entry entry : stmtDefMap.entrySet()) { final StatementDefinition key = (StatementDefinition) entry.getKey(); if (!cardinalityMap.containsKey(key)) { if (ctx.getFromNamespace(ExtensionNamespace.class, key.getStatementName()) != null) { continue; } - throw new InvalidSubstatementException(String.format("%s is not valid for %s. Error in module %s (%s)", - key, currentStatement, ctx.getRoot().getStatementArgument(), - ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())), - ctx.getStatementSourceReference()); + throw new InvalidSubstatementException(ctx.getStatementSourceReference(), + "%s is not valid for %s. Error in module %s (%s)", key, currentStatement, + ctx.getRoot().getStatementArgument(), + ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())); } if (cardinalityMap.get(key).getMin() > (Integer) entry.getValue()) { - throw new InvalidSubstatementException(String.format("Minimal count of %s for %s is %s, detected %s. " - + "Error in module %s (%s)", key, currentStatement, cardinalityMap.get(key).getMin(), - entry.getValue(), ctx.getRoot().getStatementArgument(), - ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())), - ctx.getStatementSourceReference()); + throw new InvalidSubstatementException(ctx.getStatementSourceReference(), + "Minimal count of %s for %s is %s, detected %s. Error in module %s (%s)", key, currentStatement, + cardinalityMap.get(key).getMin(), entry.getValue(), ctx.getRoot().getStatementArgument(), + ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())); } if (cardinalityMap.get(key).getMax() < (Integer) entry.getValue()) { - throw new InvalidSubstatementException(String.format("Maximal count of %s for %s is %s, detected %s. " - + "Error in module %s (%s)", key, currentStatement, cardinalityMap.get(key).getMax(), - entry.getValue(), ctx.getRoot().getStatementArgument(), - ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())), - ctx.getStatementSourceReference()); + throw new InvalidSubstatementException(ctx.getStatementSourceReference(), + "Maximal count of %s for %s is %s, detected %s. Error in module %s (%s)", key, currentStatement, + cardinalityMap.get(key).getMax(), entry.getValue(), ctx.getRoot().getStatementArgument(), + ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())); } validatedMap.put(key, 1); } final MapDifference diff = Maps.difference(validatedMap, cardinalityMap); - - for (Map.Entry entry : diff.entriesOnlyOnRight().entrySet()) { + for (Entry entry : diff.entriesOnlyOnRight().entrySet()) { final int min = ((Cardinality) entry.getValue()).getMin(); if (min > 0) { - throw new MissingSubstatementException(String.format("%s is missing %s. Minimal count is %s. Error in" - + " module %s (%s)", currentStatement, entry.getKey(), min, ctx.getRoot() - .getStatementArgument(), ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())), - ctx.getStatementSourceReference()); + throw new MissingSubstatementException(ctx.getStatementSourceReference(), + "%s is missing %s. Minimal count is %s. Error in module %s (%s)", currentStatement, entry.getKey(), + min, ctx.getRoot().getStatementArgument(), + ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())); } } } @@ -130,13 +126,9 @@ public final class SubstatementValidator { private final int min; private final int max; - private Cardinality(int min, int max) throws YangParseException { - if (min > max) { - throw new IllegalArgumentException("Min can not be greater than max!"); - } - if (min < 0) { - throw new IllegalArgumentException("Min can not be les than 0!"); - } + private Cardinality(final int min, final int max) { + Preconditions.checkArgument(min >= 0, "Min %s cannot be less than 0!"); + Preconditions.checkArgument(min <= max, "Min %s can not be greater than max %s!", min, max); this.min = min; this.max = max; } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InferenceException.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InferenceException.java index 8e5cce13ce..c1cb981ed7 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InferenceException.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InferenceException.java @@ -12,21 +12,39 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; /** - * * Thrown when there was inference error - * */ public class InferenceException extends SourceException { - - private static final long serialVersionUID = 1L; - public InferenceException(@Nonnull String message, @Nonnull StatementSourceReference source, Throwable cause) { + public InferenceException(@Nonnull final String message, @Nonnull final StatementSourceReference source, + final Throwable cause) { super(message, source, cause); } - public InferenceException(@Nonnull String message, @Nonnull StatementSourceReference source) { + public InferenceException(@Nonnull final String message, @Nonnull final StatementSourceReference source) { super(message, source); } + public InferenceException(@Nonnull final StatementSourceReference source, @Nonnull final String format, + final Object... args) { + this(String.format(format, args), source); + } + + /** + * Throw an instance of this exception if an expression evaluates to true. If the expression evaluates to false, + * this method does nothing. + * + * @param expression Expression to be evaluated + * @param source Statement source reference + * @param format Format string, according to {@link String#format(String, Object...)}. + * @param args Format string arguments, according to {@link String#format(String, Object...)} + * @throws InferenceException if the expression evaluates to true. + */ + public static void throwIf(final boolean expression, @Nonnull final StatementSourceReference source, + @Nonnull final String format, final Object... args) { + if (expression) { + throw new InferenceException(source, format, args); + } + } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InvalidSubstatementException.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InvalidSubstatementException.java index c8678eca20..3412ee7175 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InvalidSubstatementException.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/InvalidSubstatementException.java @@ -17,11 +17,17 @@ import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReferenc public class InvalidSubstatementException extends SourceException { private static final long serialVersionUID = 1L; - public InvalidSubstatementException(@Nonnull final String message, @Nonnull final StatementSourceReference source, final Throwable cause) { + public InvalidSubstatementException(@Nonnull final String message, @Nonnull final StatementSourceReference source, + final Throwable cause) { super(message, source, cause); } public InvalidSubstatementException(@Nonnull final String message, @Nonnull final StatementSourceReference source) { super(message, source); } + + public InvalidSubstatementException(@Nonnull final StatementSourceReference source, @Nonnull final String format, + final Object... args) { + this(String.format(format, args), source); + } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/MissingSubstatementException.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/MissingSubstatementException.java index 44978aa56c..d2570dbed7 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/MissingSubstatementException.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/MissingSubstatementException.java @@ -21,7 +21,13 @@ public class MissingSubstatementException extends SourceException { super(message, source); } - public MissingSubstatementException(@Nonnull final String message, @Nonnull final StatementSourceReference source, final Throwable cause) { + public MissingSubstatementException(@Nonnull final String message, @Nonnull final StatementSourceReference source, + final Throwable cause) { super(message, source, cause); } + + public MissingSubstatementException(@Nonnull final StatementSourceReference source, @Nonnull final String format, + final Object... args) { + this(String.format(format, args), source); + } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/source/SourceException.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/source/SourceException.java index cddfe2df13..a31e549d63 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/source/SourceException.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/source/SourceException.java @@ -11,35 +11,113 @@ import com.google.common.base.Preconditions; import javax.annotation.Nonnull; /** - * * Thrown to indicate error in YANG model source. - * */ public class SourceException extends RuntimeException { - private static final long serialVersionUID = 1L; private final StatementSourceReference sourceRef; - public SourceException(@Nonnull String message,@Nonnull StatementSourceReference source) { + /** + * Create a new instance with the specified message and source. The message will be appended with + * the source reference. + * + * @param message Context message + * @param source Statement source + */ + public SourceException(@Nonnull final String message, @Nonnull final StatementSourceReference source) { super(createMessage(message, source)); sourceRef = source; } - public SourceException(@Nonnull String message,@Nonnull StatementSourceReference source, Throwable cause) { + /** + * Create a new instance with the specified message and source. The message will be appended with + * the source reference. + * + * @param message Context message + * @param source Statement source + * @param cause Underlying cause of this exception + */ + public SourceException(@Nonnull final String message, @Nonnull final StatementSourceReference source, + final Throwable cause) { super(createMessage(message, source), cause); sourceRef = source; } + /** + * Create a new instance with the specified source and a formatted message. The message will be appended with + * the source reference. + * + * @param source Statement source + * @param format Format string, according to {@link String#format(String, Object...)}. + * @param args Format string arguments, according to {@link String#format(String, Object...)} + */ + public SourceException(@Nonnull final StatementSourceReference source, @Nonnull final String format, + final Object... args) { + this(String.format(format, args), source); + } + + /** + * Create a new instance with the specified source and a formatted message. The message will be appended with + * the source reference. + * + * @param source Statement source + * @param cause Underlying cause of this exception + * @param format Format string, according to {@link String#format(String, Object...)}. + * @param args Format string arguments, according to {@link String#format(String, Object...)} + */ + public SourceException(@Nonnull final StatementSourceReference source, final Throwable cause, + @Nonnull final String format, final Object... args) { + this(String.format(format, args), source, cause); + } + + /** + * Return the reference to the source which caused this exception. + * + * @return Source reference + */ public @Nonnull StatementSourceReference getSourceReference() { return sourceRef; } + /** + * Throw an instance of this exception if an expression evaluates to true. If the expression evaluates to false, + * this method does nothing. + * + * @param expression Expression to be evaluated + * @param source Statement source reference + * @param format Format string, according to {@link String#format(String, Object...)}. + * @param args Format string arguments, according to {@link String#format(String, Object...)} + * @throws SourceException if the expression evaluates to true. + */ + public static void throwIf(final boolean expression, @Nonnull final StatementSourceReference source, + @Nonnull final String format, final Object... args) { + if (expression) { + throw new SourceException(source, format, args); + } + } + + /** + * Throw an instance of this exception if an object is null. If the object is non-null, it will + * be returned as the result of this method. + * + * @param obj Object reference to be checked + * @param source Statement source reference + * @param format Format string, according to {@link String#format(String, Object...)}. + * @param args Format string arguments, according to {@link String#format(String, Object...)} + * @return Object if it is not null + * @throws SourceException if object is null + */ + @Nonnull public static T throwIfNull(final T obj, @Nonnull final StatementSourceReference source, + @Nonnull final String format, final Object... args) { + throwIf(obj == null, source, format, args); + return obj; + } + private static String createMessage(@Nonnull final String message, @Nonnull final StatementSourceReference source) { Preconditions.checkNotNull(message); Preconditions.checkNotNull(source); - return String.format("%s\nStatement source at %s", message, source); + return message + " [at " + source + ']'; } - } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java index fb23468d8d..792864eb0f 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java @@ -101,29 +101,27 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh if (def == null) { // unknown-stmts (from import, include or local-scope) if (qNameToStmtDefMap.get(name) != null) { - final StatementContextBase extension = - (StatementContextBase) currentContext.getAllFromNamespace(ExtensionNamespace.class).get(name); - if (extension != null) { - final QName arg = (QName) extension.getStatementArgument(); - final QName qName = current.getFromNamespace(QNameCacheNamespace.class, - QName.create(arg, extension.getIdentifier().getArgument())); - - def = new StatementDefinitionContext<>(new UnknownStatementImpl.Definition( - getNewStatementDefinition(qName))); - } else { - throw new SourceException("Extension not found: " + name, - current.getStatementSourceReference()); - } + final StatementContextBase extension = + (StatementContextBase) currentContext.getAllFromNamespace(ExtensionNamespace.class).get(name); + + SourceException.throwIfNull(extension, current.getStatementSourceReference(), "Extension %s not found", + name); + + final QName arg = (QName) extension.getStatementArgument(); + final QName qName = current.getFromNamespace(QNameCacheNamespace.class, + QName.create(arg, extension.getIdentifier().getArgument())); + + def = new StatementDefinitionContext<>(new UnknownStatementImpl.Definition( + getNewStatementDefinition(qName))); } else { // type-body-stmts def = resolveTypeBodyStmts(name.getLocalName()); } - } - else if (current != null && current.definition().getRepresentingClass().equals(UnknownStatementImpl.class)) { + } else if (current != null && current.definition().getRepresentingClass().equals(UnknownStatementImpl.class)) { QName qName = Utils.qNameFromArgument(current, name.getLocalName()); - def = new StatementDefinitionContext<>(new UnknownStatementImpl.Definition - (getNewStatementDefinition(qName))); + def = new StatementDefinitionContext<>(new UnknownStatementImpl.Definition( + getNewStatementDefinition(qName))); } Preconditions.checkArgument(def != null, "Statement %s does not have type mapping defined.", name); @@ -144,7 +142,7 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh return new ContextBuilder(def, ref) { @Override - public StatementContextBase build() throws SourceException { + public StatementContextBase build() { if (root == null) { root = new RootStatementContext(this, SourceSpecificContext.this); } else { @@ -259,9 +257,9 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh private static boolean tryToProgress(final Collection currentPhaseModifiers) { - - Iterator modifier = currentPhaseModifiers.iterator(); boolean hasProgressed = false; + + final Iterator modifier = currentPhaseModifiers.iterator(); while (modifier.hasNext()) { if (modifier.next().tryApply()) { modifier.remove(); @@ -352,12 +350,13 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh .class); final Map belongsToPrefixes = getRoot().getAllFromNamespace (BelongsToPrefixToModuleIdentifier.class); - if (belongsToPrefixes != null) + if (belongsToPrefixes != null) { allPrefixes.putAll(belongsToPrefixes); + } for (Entry stringModuleIdentifierEntry : allPrefixes.entrySet()) { final QNameModule namespace = getRoot().getFromNamespace(ModuleIdentifierToModuleQName.class, - stringModuleIdentifierEntry.getValue()); + stringModuleIdentifierEntry.getValue()); prefixToModuleMap.put(stringModuleIdentifierEntry.getKey(), namespace); } return prefixToModuleMap; @@ -367,22 +366,20 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh // regular YANG statements added ImmutableMap> definitions = currentContext.getSupportsForPhase( inProgressPhase).getDefinitions(); - for (Map.Entry> entry : definitions.entrySet()) { + for (Entry> entry : definitions.entrySet()) { qNameToStmtDefMap.put(entry.getKey(), entry.getValue()); } // extensions added if (inProgressPhase.equals(ModelProcessingPhase.FULL_DECLARATION)) { - Map>> extensions = currentContext - .getAllFromNamespace(ExtensionNamespace.class); + Map>> extensions = + currentContext.getAllFromNamespace(ExtensionNamespace.class); if (extensions != null) { - for (Map.Entry>> extension : extensions - .entrySet()) { - qNameToStmtDefMap - .put((extension.getKey()), - (StatementDefinition) ((StatementContextBase) extension - .getValue()).definition() - .getFactory()); + for (Entry>> extension : + extensions.entrySet()) { + qNameToStmtDefMap.put((extension.getKey()), + (StatementDefinition) ((StatementContextBase) extension.getValue()).definition() + .getFactory()); } } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java index 731f21791f..6a2d471f1c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java @@ -97,56 +97,52 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement>> sourceCtxPrereq = augmentAction - .requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL); - final Prerequisite>> target = augmentAction.mutatesEffectiveCtx(getSearchRoot(augmentNode), SchemaNodeIdentifierBuildNamespace.class, augmentNode.getStatementArgument()); + final ModelActionBuilder augmentAction = augmentNode.newInferenceAction( + ModelProcessingPhase.EFFECTIVE_MODEL); + final ModelActionBuilder.Prerequisite>> sourceCtxPrereq = + augmentAction.requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL); + final Prerequisite>> target = + augmentAction.mutatesEffectiveCtx(getSearchRoot(augmentNode), SchemaNodeIdentifierBuildNamespace.class, augmentNode.getStatementArgument()); augmentAction.apply(new ModelActionBuilder.InferenceAction() { @Override - public void apply() throws InferenceException { + public void apply() { final StatementContextBase augmentTargetCtx = (StatementContextBase) target.get(); - if (!AugmentUtils.isSupportedAugmentTarget(augmentTargetCtx) || StmtContextUtils.isInExtensionBody(augmentTargetCtx)) { augmentNode.setIsSupportedToBuildEffective(false); return; } + + // FIXME: this is a workaround for models which augment a node which is added via an extension + // which we do not handle. This needs to be reworked in terms of unknown schema nodes. final StatementContextBase augmentSourceCtx = (StatementContextBase) augmentNode; try { - AugmentUtils.copyFromSourceToTarget(augmentSourceCtx, - augmentTargetCtx); - augmentTargetCtx - .addEffectiveSubstatement(augmentSourceCtx); + AugmentUtils.copyFromSourceToTarget(augmentSourceCtx, augmentTargetCtx); + augmentTargetCtx.addEffectiveSubstatement(augmentSourceCtx); updateAugmentOrder(augmentSourceCtx); } catch (SourceException e) { - LOG.warn(e.getMessage(), e); + LOG.warn("Failed to add augmentation %s defined at {}", + augmentSourceCtx.getStatementSourceReference(), e); } - } - private void updateAugmentOrder( - final StatementContextBase augmentSourceCtx) { - Integer currentOrder = augmentSourceCtx - .getFromNamespace(StmtOrderingNamespace.class, - Rfc6020Mapping.AUGMENT); + private void updateAugmentOrder(final StatementContextBase augmentSourceCtx) { + Integer currentOrder = augmentSourceCtx.getFromNamespace(StmtOrderingNamespace.class, + Rfc6020Mapping.AUGMENT); if (currentOrder == null) { currentOrder = 1; } else { currentOrder++; } + augmentSourceCtx.setOrder(currentOrder); - augmentSourceCtx.addToNs(StmtOrderingNamespace.class, - Rfc6020Mapping.AUGMENT, currentOrder); + augmentSourceCtx.addToNs(StmtOrderingNamespace.class, Rfc6020Mapping.AUGMENT, currentOrder); } @Override - public void prerequisiteFailed( - final Collection> failed) - throws InferenceException { - throw new InferenceException("Augment target not found: " - + augmentNode.getStatementArgument(), augmentNode - .getStatementSourceReference()); + public void prerequisiteFailed(final Collection> failed) { + throw new InferenceException(augmentNode.getStatementSourceReference(), + "Augment target '%s' not found", augmentNode.getStatementArgument()); } }); } @@ -154,7 +150,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement getSearchRoot(final Mutable augmentContext) { Mutable parent = augmentContext.getParentContext(); // Augment is in uses - we need to augment instantiated nodes in parent. - if(Rfc6020Mapping.USES.equals(parent.getPublicDefinition())) { + if (Rfc6020Mapping.USES.equals(parent.getPublicDefinition())) { return parent.getParentContext(); } return parent; 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 c873ddbfbc..c835eb24fe 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 @@ -96,13 +96,11 @@ public final class AugmentUtils { .addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build(); for (final StatementContextBase sourceSubStatement : sourceSubStatements) { - if (sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass() - .equals(MandatoryStatement.class)) { - throw new InferenceException( - String.format( - "An augment cannot add node '%s' because it is mandatory and in module different from target", - sourceCtx.rawStatementArgument()), sourceCtx.getStatementSourceReference()); - } + 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()); } } @@ -115,11 +113,9 @@ public final class AugmentUtils { boolean qNamesEqual = sourceIsDataNode && targetIsDataNode && Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument()); - if (qNamesEqual) { - throw new InferenceException(String.format( - "An augment cannot add node named '%s' because this name is already used in target", - sourceCtx.rawStatementArgument()), sourceCtx.getStatementSourceReference()); - } + InferenceException.throwIf(qNamesEqual, sourceCtx.getStatementSourceReference(), + "An augment cannot add node named '%s' because this name is already used in target", + sourceCtx.rawStatementArgument()); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java index a14a557c24..9fdf95ae95 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java @@ -28,13 +28,11 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase; 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.StmtContextUtils; -import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BaseEffectiveStatementImpl; public class BaseStatementImpl extends AbstractDeclaredStatement implements BaseStatement { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping - .BASE) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(Rfc6020Mapping.BASE).build(); protected BaseStatementImpl(final StmtContext context) { super(context); @@ -70,14 +68,16 @@ public class BaseStatementImpl extends AbstractDeclaredStatement implemen if (StmtContextUtils.producesDeclared(baseParentCtx, IdentityStatement.class)) { final QName baseIdentityQName = baseStmtCtx.getStatementArgument(); - ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction(ModelProcessingPhase.STATEMENT_DEFINITION); - final Prerequisite> requiresPrereq = baseIdentityAction.requiresCtx(baseStmtCtx, IdentityNamespace.class, baseIdentityQName, ModelProcessingPhase.STATEMENT_DEFINITION); - final Prerequisite> mutatesPrereq = baseIdentityAction.mutatesCtx - (baseParentCtx, ModelProcessingPhase.STATEMENT_DEFINITION); + final ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction( + ModelProcessingPhase.STATEMENT_DEFINITION); + final Prerequisite> requiresPrereq = baseIdentityAction.requiresCtx(baseStmtCtx, + IdentityNamespace.class, baseIdentityQName, ModelProcessingPhase.STATEMENT_DEFINITION); + final Prerequisite> mutatesPrereq = baseIdentityAction.mutatesCtx( + baseParentCtx, ModelProcessingPhase.STATEMENT_DEFINITION); baseIdentityAction.apply(new InferenceAction() { @Override - public void apply() throws InferenceException { + public void apply() { List> derivedIdentities = baseStmtCtx.getFromNamespace(DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument()); if (derivedIdentities == null) { @@ -89,17 +89,17 @@ public class BaseStatementImpl extends AbstractDeclaredStatement implemen @Override public void prerequisiteFailed(final Collection> failed) { - throw new InferenceException( - "Unable to resolve identity " + baseParentCtx.getStatementArgument() + " and base identity " - + baseStmtCtx.getStatementArgument(), baseStmtCtx.getStatementSourceReference()); + throw new InferenceException(baseStmtCtx.getStatementSourceReference(), + "Unable to resolve identity %s and base identity %s", + baseParentCtx.getStatementArgument(), baseStmtCtx.getStatementArgument()); } }); } } @Override - public void onFullDefinitionDeclared(Mutable> stmt) throws SourceException { + public void onFullDefinitionDeclared( + final Mutable> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java index dd8c76b3a0..0b5cb9a095 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java @@ -29,18 +29,14 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToModuleContext; import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleIdentifier; import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNamespaceForBelongsTo; -import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BelongsEffectiveToStatementImpl; public class BelongsToStatementImpl extends AbstractDeclaredStatement implements BelongsToStatement { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping - .BELONGS_TO) - .add(Rfc6020Mapping.PREFIX, 1, 1) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(Rfc6020Mapping.BELONGS_TO).add(Rfc6020Mapping.PREFIX, 1, 1).build(); - protected BelongsToStatementImpl( - final StmtContext context) { + protected BelongsToStatementImpl(final StmtContext context) { super(context); } @@ -70,43 +66,46 @@ public class BelongsToStatementImpl extends AbstractDeclaredStatement } @Override - public void onLinkageDeclared(final StmtContext.Mutable> belongsToCtx) throws SourceException { + public void onLinkageDeclared( + final StmtContext.Mutable> belongsToCtx) { ModelActionBuilder belongsToAction = belongsToCtx.newInferenceAction(ModelProcessingPhase.SOURCE_LINKAGE); final ModuleIdentifier belongsToModuleIdentifier = getModuleIdentifier(belongsToCtx); - final ModelActionBuilder.Prerequisite> belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx, ModuleNamespaceForBelongsTo.class, belongsToModuleIdentifier.getName(), ModelProcessingPhase.SOURCE_LINKAGE); + final ModelActionBuilder.Prerequisite> belongsToPrereq = belongsToAction.requiresCtx( + belongsToCtx, ModuleNamespaceForBelongsTo.class, belongsToModuleIdentifier.getName(), + ModelProcessingPhase.SOURCE_LINKAGE); belongsToAction.apply(new InferenceAction() { - @Override - public void apply() throws InferenceException { + public void apply() { StmtContext belongsToModuleCtx = belongsToPrereq.get(); - belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToModuleIdentifier, - belongsToModuleCtx); - belongsToCtx.addToNs(BelongsToPrefixToModuleIdentifier.class, StmtContextUtils - .findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).getStatementArgument - (), belongsToModuleIdentifier); + belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToModuleIdentifier, belongsToModuleCtx); + belongsToCtx.addToNs(BelongsToPrefixToModuleIdentifier.class, + StmtContextUtils.findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class) + .getStatementArgument(), belongsToModuleIdentifier); } @Override - public void prerequisiteFailed(final Collection> failed) throws InferenceException { + public void prerequisiteFailed(final Collection> failed) { if (failed.contains(belongsToPrereq)) { - throw new InferenceException("Module from belongs-to was not found: " + belongsToCtx.getStatementArgument(), belongsToCtx - .getStatementSourceReference()); + throw new InferenceException(belongsToCtx.getStatementSourceReference(), + "Module '%s' from belongs-to was not found", belongsToCtx.getStatementArgument()); } } }); } - private static ModuleIdentifier getModuleIdentifier(final StmtContext.Mutable> belongsToCtx) { + private static ModuleIdentifier getModuleIdentifier( + final StmtContext.Mutable> belongsToCtx) { String moduleName = belongsToCtx.getStatementArgument(); - return new ModuleIdentifierImpl(moduleName, Optional. absent(), Optional.of(SimpleDateFormatUtil.DEFAULT_BELONGS_TO_DATE)); + return new ModuleIdentifierImpl(moduleName, Optional. absent(), + Optional.of(SimpleDateFormatUtil.DEFAULT_BELONGS_TO_DATE)); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable> stmt) throws SourceException { + public void onFullDefinitionDeclared(final StmtContext.Mutable> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingUtils.java index e28a1c6bb9..7f92ae4a74 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingUtils.java @@ -179,15 +179,12 @@ public final class GroupingUtils { StatementDefinition refineSubstatementDef = refineSubstatementCtx.getPublicDefinition(); StatementDefinition refineTargetNodeDef = refineTargetNodeCtx.getPublicDefinition(); - if (!isSupportedRefineTarget(refineSubstatementCtx, refineTargetNodeCtx)) { - throw new SourceException("Error in module '" - + refineSubstatementCtx.getRoot().getStatementArgument() - + "' in the refine of uses '" - + refineSubstatementCtx.getParentContext().getStatementArgument() - + "': can not perform refine of '" + refineSubstatementCtx.getPublicDefinition() - + "' for the target '" + refineTargetNodeCtx.getPublicDefinition() + "'.", - refineSubstatementCtx.getStatementSourceReference()); - } + SourceException.throwIf(!isSupportedRefineTarget(refineSubstatementCtx, refineTargetNodeCtx), + refineSubstatementCtx.getStatementSourceReference(), + "Error in module '%s' in the refine of uses '%s': can not perform refine of '%s' for the target '%s'.", + refineSubstatementCtx.getRoot().getStatementArgument(), + refineSubstatementCtx.getParentContext().getStatementArgument(), + refineSubstatementCtx.getPublicDefinition(), refineTargetNodeCtx.getPublicDefinition()); if (isAllowedToAddByRefine(refineSubstatementDef)) { refineTargetNodeCtx.addEffectiveSubstatement(refineSubstatementCtx); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java index 5832cf68f3..6bf310158f 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java @@ -9,7 +9,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; - import com.google.common.base.Optional; import java.net.URI; import java.util.Collection; @@ -36,16 +35,13 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prereq 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.ImpPrefixToModuleIdentifier; -import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ImportEffectiveStatementImpl; public class ImportStatementDefinition extends AbstractStatementSupport> { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping - .IMPORT) - .add(Rfc6020Mapping.PREFIX, 1, 1) - .add(Rfc6020Mapping.REVISION_DATE, 0, 1) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(Rfc6020Mapping.IMPORT) + .add(Rfc6020Mapping.PREFIX, 1, 1).add(Rfc6020Mapping.REVISION_DATE, 0, 1).build(); public ImportStatementDefinition() { super(Rfc6020Mapping.IMPORT); @@ -57,8 +53,7 @@ public class ImportStatementDefinition } @Override - public ImportStatement createDeclared( - final StmtContext ctx) { + public ImportStatement createDeclared(final StmtContext ctx) { return new ImportStatementImpl(ctx); } @@ -69,8 +64,8 @@ public class ImportStatementDefinition } @Override - public void onFullDefinitionDeclared(Mutable> stmt) throws SourceException { + public void onFullDefinitionDeclared( + final Mutable> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); } @@ -86,12 +81,12 @@ public class ImportStatementDefinition importAction.apply(new InferenceAction() { @Override - public void apply() throws InferenceException { + public void apply() { StmtContext importedModule = null; ModuleIdentifier importedModuleIdentifier = null; if (impIdentifier.getRevision() == SimpleDateFormatUtil.DEFAULT_DATE_IMP) { - Entry>> recentModuleEntry = findRecentModule( - impIdentifier, stmt.getAllFromNamespace(ModuleNamespace.class)); + Entry>> recentModuleEntry = + findRecentModule(impIdentifier, stmt.getAllFromNamespace(ModuleNamespace.class)); if (recentModuleEntry != null) { importedModuleIdentifier = recentModuleEntry.getKey(); importedModule = recentModuleEntry.getValue(); @@ -119,9 +114,11 @@ public class ImportStatementDefinition Entry>> recentModuleEntry = null; for (Entry>> moduleEntry : allModules.entrySet()) { - if (moduleEntry.getKey().getName().equals(impIdentifier.getName()) - && moduleEntry.getKey().getRevision().compareTo(recentModuleIdentifier.getRevision()) > 0) { - recentModuleIdentifier = moduleEntry.getKey(); + final ModuleIdentifier id = moduleEntry.getKey(); + + if (id.getName().equals(impIdentifier.getName()) + && id.getRevision().compareTo(recentModuleIdentifier.getRevision()) > 0) { + recentModuleIdentifier = id; recentModuleEntry = moduleEntry; } } @@ -132,8 +129,8 @@ public class ImportStatementDefinition @Override public void prerequisiteFailed(final Collection> failed) { if (failed.contains(imported)) { - throw new InferenceException(String.format("Imported module [%s] was not found.", impIdentifier), - stmt.getStatementSourceReference()); + throw new InferenceException(stmt.getStatementSourceReference(), + "Imported module [%s] was not found.", impIdentifier); } } }); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java index d5869d6cf9..872426cf35 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java @@ -9,7 +9,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; - import com.google.common.base.Optional; import java.net.URI; import java.util.Collection; @@ -37,12 +36,10 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IncludeEffectiveStatementImpl; public class IncludeStatementImpl extends AbstractDeclaredStatement implements IncludeStatement { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping - .INCLUDE) - .add(Rfc6020Mapping.REVISION_DATE, 0, 1) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder( + Rfc6020Mapping.INCLUDE).add(Rfc6020Mapping.REVISION_DATE, 0, 1).build(); - protected IncludeStatementImpl(StmtContext context) { + protected IncludeStatementImpl(final StmtContext context) { super(context); } @@ -54,25 +51,24 @@ public class IncludeStatementImpl extends AbstractDeclaredStatement impl } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override - public IncludeStatement createDeclared(StmtContext ctx) { + public IncludeStatement createDeclared(final StmtContext ctx) { return new IncludeStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new IncludeEffectiveStatementImpl(ctx); } @Override public void onLinkageDeclared( - final Mutable> stmt) - throws SourceException { + final Mutable> stmt) { final ModuleIdentifier includeSubmoduleIdentifier = getIncludeSubmoduleIdentifier(stmt); ModelActionBuilder includeAction = stmt.newInferenceAction(SOURCE_LINKAGE); @@ -80,9 +76,8 @@ public class IncludeStatementImpl extends AbstractDeclaredStatement impl SubmoduleNamespace.class, includeSubmoduleIdentifier, SOURCE_LINKAGE); includeAction.apply(new InferenceAction() { - @Override - public void apply() throws InferenceException { + public void apply() { StmtContext includedSubModuleContext = requiresCtxPrerequisite.get(); stmt.addToNs(IncludedModuleContext.class, includeSubmoduleIdentifier, @@ -92,16 +87,15 @@ public class IncludeStatementImpl extends AbstractDeclaredStatement impl } @Override - public void prerequisiteFailed(Collection> failed) throws InferenceException { - if (failed.contains(requiresCtxPrerequisite)) { - throw new InferenceException("Included submodule was not found: "+stmt.getStatementArgument(), stmt - .getStatementSourceReference()); - } + public void prerequisiteFailed(final Collection> failed) { + InferenceException.throwIf(failed.contains(requiresCtxPrerequisite), + stmt.getStatementSourceReference(), + "Included submodule '%s' was not found: ", stmt.getStatementArgument()); } }); } - private static ModuleIdentifier getIncludeSubmoduleIdentifier(Mutable stmt) { + private static ModuleIdentifier getIncludeSubmoduleIdentifier(final Mutable stmt) { String subModuleName = stmt.getStatementArgument(); @@ -114,7 +108,7 @@ public class IncludeStatementImpl extends AbstractDeclaredStatement impl } @Override - public void onFullDefinitionDeclared(Mutable> stmt) throws SourceException { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ModuleStatementSupport.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ModuleStatementSupport.java index ea6d565b89..f66e2b96c0 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ModuleStatementSupport.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ModuleStatementSupport.java @@ -9,7 +9,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; - import com.google.common.base.Optional; import java.net.URI; import java.util.Date; @@ -75,31 +74,28 @@ public class ModuleStatementSupport extends } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override - public ModuleStatement createDeclared(StmtContext ctx) { + public ModuleStatement createDeclared(final StmtContext ctx) { return new ModuleStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new ModuleEffectiveStatementImpl(ctx); } @Override - public void onLinkageDeclared(Mutable> stmt) - throws SourceException { + public void onLinkageDeclared(final Mutable> stmt) { Optional moduleNs = Optional.fromNullable(firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class)); - if (!moduleNs.isPresent()) { - throw new SourceException(String.format("Namespace of the module [%s] is missing", - stmt.getStatementArgument()), stmt.getStatementSourceReference()); - } + SourceException.throwIf(!moduleNs.isPresent(), stmt.getStatementSourceReference(), + "Namespace of the module [%s] is missing", stmt.getStatementArgument()); Optional revisionDate = Optional.fromNullable(Utils.getLatestRevision(stmt.declaredSubstatements())); if (!revisionDate.isPresent()) { @@ -114,23 +110,20 @@ public class ModuleStatementSupport extends stmt.addContext(ModuleNamespaceForBelongsTo.class, moduleIdentifier.getName(), stmt); stmt.addContext(NamespaceToModule.class, qNameModule, stmt); - String modulePrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class); - if (modulePrefix == null) { - throw new SourceException(String.format("Prefix of the module [%s] is missing", - stmt.getStatementArgument()), stmt.getStatementSourceReference()); - } + final String modulePrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class); + SourceException.throwIfNull(modulePrefix, stmt.getStatementSourceReference(), + "Prefix of the module [%s] is missing", stmt.getStatementArgument()); stmt.addToNs(PrefixToModule.class, modulePrefix, qNameModule); stmt.addToNs(ModuleNameToModuleQName.class, stmt.getStatementArgument(), qNameModule); stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule); stmt.addToNs(ModuleQNameToModuleName.class, qNameModule, stmt.getStatementArgument()); stmt.addToNs(ModuleIdentifierToModuleQName.class, moduleIdentifier, qNameModule); - stmt.addToNs(ImpPrefixToModuleIdentifier.class, modulePrefix, moduleIdentifier); } @Override - public void onFullDefinitionDeclared(Mutable> stmt) throws SourceException { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionDateStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionDateStatementImpl.java index 0e6ef322fb..28d4ee82b0 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionDateStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionDateStatementImpl.java @@ -20,14 +20,11 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionDateEffectiveStatementImpl; -public class RevisionDateStatementImpl extends - AbstractDeclaredStatement implements RevisionDateStatement { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping - .REVISION_DATE) - .build(); +public class RevisionDateStatementImpl extends AbstractDeclaredStatement implements RevisionDateStatement { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(Rfc6020Mapping.REVISION_DATE).build(); - protected RevisionDateStatementImpl( - StmtContext context) { + protected RevisionDateStatementImpl(final StmtContext context) { super(context); } @@ -40,34 +37,29 @@ public class RevisionDateStatementImpl extends } @Override - public Date parseArgumentValue(StmtContext ctx, String value) throws SourceException { - Date revision; + public Date parseArgumentValue(final StmtContext ctx, final String value) throws SourceException { try { - revision = SimpleDateFormatUtil.getRevisionFormat() - .parse(value); + return SimpleDateFormatUtil.getRevisionFormat().parse(value); } catch (ParseException e) { - throw new SourceException(String.format("Revision value %s is not in required format yyyy-MM-dd", - value), ctx.getStatementSourceReference(), e); + throw new SourceException(ctx.getStatementSourceReference(), e, + "Revision value %s is not in required format yyyy-MM-dd", value); } - - return revision; } @Override - public RevisionDateStatement createDeclared( - StmtContext ctx) { + public RevisionDateStatement createDeclared(final StmtContext ctx) { return new RevisionDateStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new RevisionDateEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable> stmt) throws SourceException { + public void onFullDefinitionDeclared( + final StmtContext.Mutable> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); } @@ -77,5 +69,4 @@ public class RevisionDateStatementImpl extends public Date getDate() { return argument(); } - } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionStatementImpl.java index 16ef33e27b..5ac7643521 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionStatementImpl.java @@ -25,14 +25,11 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionEff public class RevisionStatementImpl extends AbstractDeclaredStatement implements RevisionStatement { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping - .REVISION) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder( + Rfc6020Mapping.REVISION) + .add(Rfc6020Mapping.DESCRIPTION, 0, 1).add(Rfc6020Mapping.REFERENCE, 0, 1).build(); - protected RevisionStatementImpl( - StmtContext context) { + protected RevisionStatementImpl(final StmtContext context) { super(context); } @@ -45,35 +42,29 @@ public class RevisionStatementImpl extends AbstractDeclaredStatement } @Override - public Date parseArgumentValue(StmtContext ctx, String value) - throws SourceException { - Date revision; + public Date parseArgumentValue(final StmtContext ctx, final String value) { try { - revision = SimpleDateFormatUtil.getRevisionFormat() - .parse(value); + return SimpleDateFormatUtil.getRevisionFormat().parse(value); } catch (ParseException e) { - throw new SourceException(String.format("Revision value %s is not in required format yyyy-MM-dd", - value), ctx.getStatementSourceReference(), e); + throw new SourceException(ctx.getStatementSourceReference(), e, + "Revision value %s is not in required format yyyy-MM-dd", value); } - - return revision; } @Override - public RevisionStatement createDeclared( - StmtContext ctx) { + public RevisionStatement createDeclared(final StmtContext ctx) { return new RevisionStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new RevisionEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable> stmt) throws SourceException { + public void onFullDefinitionDeclared( + final StmtContext.Mutable> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/SubmoduleStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/SubmoduleStatementImpl.java index 41c0a5343d..5516f9debc 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/SubmoduleStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/SubmoduleStatementImpl.java @@ -10,7 +10,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; - import com.google.common.base.Optional; import java.net.URI; import java.util.Date; @@ -61,8 +60,9 @@ public class SubmoduleStatementImpl extends AbstractRootStatement DEFAULT_REVISION = Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_REV); - protected SubmoduleStatementImpl(StmtContext context) { + protected SubmoduleStatementImpl(final StmtContext context) { super(context); } @@ -74,35 +74,32 @@ public class SubmoduleStatementImpl extends AbstractRootStatement ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public SubmoduleStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new SubmoduleStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new SubmoduleEffectiveStatementImpl(ctx); } @Override public void onLinkageDeclared( - Mutable> stmt) + final Mutable> stmt) throws SourceException { - Optional revisionDate = Optional.fromNullable(Utils.getLatestRevision(stmt.declaredSubstatements())); - if (!revisionDate.isPresent()) { - revisionDate = Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_REV); - } + final Optional revisionDate = Optional.fromNullable( + Utils.getLatestRevision(stmt.declaredSubstatements())).or(DEFAULT_REVISION); - ModuleIdentifier submoduleIdentifier = new ModuleIdentifierImpl( - stmt.getStatementArgument(), Optional. absent(), - revisionDate); + ModuleIdentifier submoduleIdentifier = new ModuleIdentifierImpl(stmt.getStatementArgument(), + Optional. absent(), revisionDate); stmt.addContext(SubmoduleNamespace.class, submoduleIdentifier, stmt); @@ -110,20 +107,16 @@ public class SubmoduleStatementImpl extends AbstractRootStatement prefixSubStmtCtx = findFirstDeclaredSubstatement( stmt, 0, BelongsToStatement.class, PrefixStatement.class); - - if (prefixSubStmtCtx == null) { - throw new SourceException(String.format("Prefix of belongsTo statement is missing in submodule [%s]", - stmt.getStatementArgument()), stmt.getStatementSourceReference()); - } + SourceException.throwIfNull(prefixSubStmtCtx, stmt.getStatementSourceReference(), + "Prefix of belongsTo statement is missing in submodule [%s]", stmt.getStatementArgument()); String prefix = (String) prefixSubStmtCtx.getStatementArgument(); - stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, - belongsToModuleName); + stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName); } @Override - public void onFullDefinitionDeclared(Mutable> stmt) throws SourceException { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java index de9ea479bb..8253d60d37 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java @@ -8,7 +8,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import com.google.common.base.Verify; import java.util.Collection; import javax.annotation.Nonnull; @@ -151,9 +150,7 @@ public class TypeStatementImpl extends AbstractDeclaredStatement final QName qname = Utils.qNameFromArgument(ctx, ctx.getStatementArgument()); final StmtContext typedef = ctx.getFromNamespace(TypeNamespace.class, qname); - if (typedef == null) { - throw new SourceException("Type '" + qname + "' not found", ctx.getStatementSourceReference()); - } + SourceException.throwIfNull(typedef, ctx.getStatementSourceReference(), "Type '%s' not found", qname); final TypedefEffectiveStatement effectiveTypedef = typedef.buildEffective(); Verify.verify(effectiveTypedef instanceof TypeDefEffectiveStatementImpl); @@ -199,8 +196,7 @@ public class TypeStatementImpl extends AbstractDeclaredStatement @Override public void onFullDefinitionDeclared( - final Mutable> stmt) - throws SourceException { + final Mutable> stmt){ SUBSTATEMENT_VALIDATOR.validate(stmt); // if it is yang built-in type, no prerequisite is needed, so simply return @@ -219,18 +215,15 @@ public class TypeStatementImpl extends AbstractDeclaredStatement * Otherwise perform no operation. */ typeAction.apply(new InferenceAction() { - @Override public void apply() { // Intentional NOOP } @Override - public void prerequisiteFailed(Collection> failed) { - if (failed.contains(typePrereq)) { - throw new InferenceException(String.format("Type [%s] was not found.", typeQName), stmt - .getStatementSourceReference()); - } + public void prerequisiteFailed(final Collection> failed) { + InferenceException.throwIf(failed.contains(typePrereq), stmt.getStatementSourceReference(), + "Type [%s] was not found.", typeQName); } }); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeUtils.java index 3aee370272..cd579073d6 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeUtils.java @@ -135,23 +135,19 @@ public final class TypeUtils { max = parseDecimalConstraintValue(ctx, boundaries.next()); // if min larger than max then error - if (compareNumbers(min, max) == 1) { - throw new InferenceException(String.format( - "Range constraint %s has descending order of boundaries; should be ascending", - singleRange), ctx.getStatementSourceReference()); - } - if (boundaries.hasNext()) { - throw new SourceException(String.format("Wrong number of boundaries in range constraint %s", - singleRange), ctx.getStatementSourceReference()); - } + InferenceException.throwIf(compareNumbers(min, max) == 1, ctx.getStatementSourceReference(), + "Range constraint %s has descending order of boundaries; should be ascending", singleRange); + + SourceException.throwIf(boundaries.hasNext(), ctx.getStatementSourceReference(), + "Wrong number of boundaries in range constraint %s", singleRange); } else { max = min; } // some of intervals overlapping if (rangeConstraints.size() > 1 && compareNumbers(min, Iterables.getLast(rangeConstraints).getMax()) != 1) { - throw new InferenceException(String.format("Some of the ranges in %s are not disjoint", - rangeArgument), ctx.getStatementSourceReference()); + throw new InferenceException(ctx.getStatementSourceReference(), + "Some of the ranges in %s are not disjoint", rangeArgument); } rangeConstraints.add(new RangeConstraintEffectiveImpl(min, max, description, reference)); @@ -188,8 +184,8 @@ public final class TypeUtils { // some of intervals overlapping if (rangeConstraints.size() > 1 && compareNumbers(min, Iterables.getLast(rangeConstraints).getMax()) != 1) { - throw new InferenceException(String.format("Some of the length ranges in %s are not disjoint", - rangeArgument), ctx.getStatementSourceReference()); + throw new InferenceException(ctx.getStatementSourceReference(), + "Some of the length ranges in %s are not disjoint", rangeArgument); } rangeConstraints.add(new LengthConstraintEffectiveImpl(min, max, description, reference)); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypedefStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypedefStatementImpl.java index 9d3fb3ef1a..b96a2708e4 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypedefStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypedefStatementImpl.java @@ -15,6 +15,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement; import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator; @@ -36,7 +37,7 @@ public class TypedefStatementImpl extends AbstractDeclaredStatement imple .add(Rfc6020Mapping.UNITS, 0, 1) .build(); - protected TypedefStatementImpl(StmtContext context) { + protected TypedefStatementImpl(final StmtContext context) { super(context); } @@ -48,37 +49,36 @@ public class TypedefStatementImpl extends AbstractDeclaredStatement imple } @Override - public QName parseArgumentValue(StmtContext ctx, String value) throws SourceException { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override - public TypedefStatement createDeclared(StmtContext ctx) { + public TypedefStatement createDeclared(final StmtContext ctx) { return new TypedefStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new TypeDefEffectiveStatementImpl(ctx); } @Override public void onStatementDefinitionDeclared( - StmtContext.Mutable> stmt) - throws SourceException { + final StmtContext.Mutable> stmt) { if (stmt != null && stmt.getParentContext() != null) { - if (stmt.getParentContext().getFromNamespace(TypeNamespace.class, stmt.getStatementArgument()) != null) { - throw new SourceException(String.format("Duplicate name for typedef %s", - stmt.getStatementArgument()), stmt.getStatementSourceReference()); - } + final StmtContext existing = + stmt.getParentContext().getFromNamespace(TypeNamespace.class, stmt.getStatementArgument()); + SourceException.throwIf(existing != null, stmt.getStatementSourceReference(), + "Duplicate name for typedef %s", stmt.getStatementArgument()); stmt.getParentContext().addContext(TypeNamespace.class, stmt.getStatementArgument(), stmt); } } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable> stmt) throws SourceException { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java index 154467fb19..a5872bd614 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java @@ -8,7 +8,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; @@ -75,7 +74,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement implemen throws SourceException { SUBSTATEMENT_VALIDATOR.validate(usesNode); - if(StmtContextUtils.isInExtensionBody(usesNode)) { + if (StmtContextUtils.isInExtensionBody(usesNode)) { return; } @@ -90,7 +89,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement implemen usesAction.apply(new InferenceAction() { @Override - public void apply() throws InferenceException { + public void apply() { StatementContextBase targetNodeStmtCtx = (StatementContextBase) targetNodePre.get(); StatementContextBase sourceGrpStmtCtx = (StatementContextBase) sourceGroupingPre.get(); @@ -104,11 +103,9 @@ public class UsesStatementImpl extends AbstractDeclaredStatement implemen } @Override - public void prerequisiteFailed(final Collection> failed) throws InferenceException { - if (failed.contains(sourceGroupingPre)) { - throw new InferenceException("Grouping " + groupingName + " was not resolved.", usesNode - .getStatementSourceReference()); - } + public void prerequisiteFailed(final Collection> failed) { + InferenceException.throwIf(failed.contains(sourceGroupingPre), + usesNode.getStatementSourceReference(), "Grouping '%s' was not resolved.", groupingName); throw new InferenceException("Unknown error occurred.", usesNode.getStatementSourceReference()); } }); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java index a19e00df1c..3123445b47 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java @@ -107,8 +107,7 @@ public final class Utils { // to detect if key contains duplicates if ((new HashSet<>(keyTokens)).size() < keyTokens.size()) { // FIXME: report all duplicate keys - throw new SourceException(String.format("Duplicate value in list key: %s", value), - ctx.getStatementSourceReference()); + throw new SourceException(ctx.getStatementSourceReference(), "Duplicate value in list key: %s", value); } Set keyNodes = new HashSet<>(); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java index 04415543bb..de640644cd 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java @@ -49,10 +49,9 @@ abstract class AbstractEffectiveDocumentedDataNodeContainer effectiveStatement : effectiveSubstatements) { if (effectiveStatement instanceof DataSchemaNode) { - DataSchemaNode dataSchemaNode = (DataSchemaNode) effectiveStatement; + final DataSchemaNode dataSchemaNode = (DataSchemaNode) effectiveStatement; if (!mutableChildNodes.containsKey(dataSchemaNode.getQName())) { - mutableChildNodes.put(dataSchemaNode.getQName(), - dataSchemaNode); + mutableChildNodes.put(dataSchemaNode.getQName(), dataSchemaNode); mutablePublicChildNodes.add(dataSchemaNode); } else { throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStmtUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStmtUtils.java index 854b857dfe..63c5b10da1 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStmtUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStmtUtils.java @@ -12,22 +12,18 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; -public final class EffectiveStmtUtils { +final class EffectiveStmtUtils { private EffectiveStmtUtils() { throw new UnsupportedOperationException("Utility class"); } - public static SourceException createNameCollisionSourceException(final StmtContext ctx, + static SourceException createNameCollisionSourceException(final StmtContext ctx, final EffectiveStatement effectiveStatement) { - return new SourceException("Error in module '" - + ctx.getRoot().getStatementArgument() - + "': can not add '" - + effectiveStatement.argument() - + "'. Node name collision: '" - + effectiveStatement.argument() - + "' already declared.", - ctx.getStatementSourceReference()); + return new SourceException(ctx.getStatementSourceReference(), + "Error in module '%s': cannot add '%s'. Node name collision: '%s' already declared.", + ctx.getRoot().getStatementArgument(), + effectiveStatement.argument(), + effectiveStatement.argument()); } - } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java index 03fde57ee2..d9f6fb6b2c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java @@ -31,7 +31,7 @@ public class ImportEffectiveStatementImpl extends DeclaredEffectiveStatementBase this.revision = (revisionDateStmt == null) ? SimpleDateFormatUtil.DEFAULT_DATE_IMP : revisionDateStmt.argument(); PrefixEffectiveStatementImpl prefixStmt = firstEffective(PrefixEffectiveStatementImpl.class); - if (prefixStmt != null ) { + if (prefixStmt != null) { this.prefix = prefixStmt.argument(); } else { throw new MissingSubstatementException("Prefix is mandatory substatement of import statement", diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java index 70d8039469..113a5d49e9 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java @@ -32,10 +32,9 @@ public final class LeafEffectiveStatementImpl extends AbstractEffectiveDataSchem super(ctx); this.original = ctx.getOriginalCtx() == null ? null : (LeafSchemaNode) ctx.getOriginalCtx().buildEffective(); - final TypeEffectiveStatement typeStmt = firstSubstatementOfType(TypeEffectiveStatement.class); - if (typeStmt == null) { - throw new SourceException("Leaf is missing a 'type' statement", ctx.getStatementSourceReference()); - } + final TypeEffectiveStatement typeStmt = SourceException.throwIfNull( + firstSubstatementOfType(TypeEffectiveStatement.class), ctx.getStatementSourceReference(), + "Leaf is missing a 'type' statement"); String dflt = null; String units = null; diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java index 6d9a5f6f42..7f391833ba 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java @@ -35,10 +35,9 @@ public final class LeafListEffectiveStatementImpl extends AbstractEffectiveDataS this.original = ctx.getOriginalCtx() == null ? null : (LeafListSchemaNode) ctx.getOriginalCtx() .buildEffective(); - final TypeEffectiveStatement typeStmt = firstSubstatementOfType(TypeEffectiveStatement.class); - if (typeStmt == null) { - throw new SourceException("Leaf-list is missing a 'type' statement", ctx.getStatementSourceReference()); - } + final TypeEffectiveStatement typeStmt = SourceException.throwIfNull( + firstSubstatementOfType(TypeEffectiveStatement.class), ctx.getStatementSourceReference(), + "Leaf-list is missing a 'type' statement"); final ConcreteTypeBuilder builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(), ctx.getSchemaPath().get()); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java index cb6166415a..7dc2c2361e 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java @@ -64,9 +64,9 @@ public final class ListEffectiveStatementImpl extends AbstractEffectiveSimpleDat final QName keyQName = key.getLastComponent(); if (!possibleLeafQNamesForKey.contains(keyQName)) { - throw new InferenceException(String.format("Key '%s' misses node '%s' in list '%s'", - keyEffectiveSubstatement.getDeclared().rawArgument(), keyQName.getLocalName(), - ctx.getStatementArgument()), ctx.getStatementSourceReference()); + throw new InferenceException(ctx.getStatementSourceReference(), + "Key '%s' misses node '%s' in list '%s'", keyEffectiveSubstatement.getDeclared().rawArgument(), + keyQName.getLocalName(), ctx.getStatementArgument()); } keyDefinitionInit.add(keyQName); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BinaryTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BinaryTypeEffectiveStatementImpl.java index 3c528f7a90..62b37a3af5 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BinaryTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BinaryTypeEffectiveStatementImpl.java @@ -47,8 +47,8 @@ public final class BinaryTypeEffectiveStatementImpl extends DeclaredEffectiveSta typeDefinition = builder.build(); } catch (InvalidLengthConstraintException e) { final LengthConstraint c = e.getOffendingConstraint(); - throw new SourceException(String.format("Invalid length constraint: <%s, %s>", c.getMin(), c.getMax()), - ctx.getStatementSourceReference(), e); + throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid length constraint: <%s, %s>", + c.getMin(), c.getMax()); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java index 05374ce27c..b688f18f46 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitsSpecificationEffectiveStatementImpl.java @@ -41,17 +41,16 @@ public final class BitsSpecificationEffectiveStatementImpl extends } else if (highestPosition != 4294967295L) { newPos = highestPosition + 1; } else { - throw new SourceException("Bit " + b + " must have a position statement", - ctx.getStatementSourceReference()); + throw new SourceException(ctx.getStatementSourceReference(), + "Bit %s must have a position statement", b); } b = new BitImpl(newPos, b.getQName(), b.getPath(), b.getDescription(), b.getReference(), b.getStatus(), b.getUnknownSchemaNodes()); } - if (b.getPosition() < 0L || b.getPosition() > 4294967295L) { - throw new SourceException("Bit " + b + " has illegal position", ctx.getStatementSourceReference()); - } + SourceException.throwIf(b.getPosition() < 0L && b.getPosition() > 4294967295L, + ctx.getStatementSourceReference(), "Bit %s has illegal position", b); if (highestPosition == null || highestPosition < b.getPosition()) { highestPosition = b.getPosition(); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java index 66fc7d0d95..96dae96a9b 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumSpecificationEffectiveStatementImpl.java @@ -42,8 +42,8 @@ public final class EnumSpecificationEffectiveStatementImpl extends } else if (highestValue != 2147483647) { newValue = highestValue + 1; } else { - throw new SourceException("Enum " + p + " must have a value statement", - ctx.getStatementSourceReference()); + throw new SourceException(ctx.getStatementSourceReference(), + "Enum '%s' must have a value statement", p); } p = new EnumPairImpl(p.getName(), newValue, p.getPath(), p.getDescription(), p.getReference(), diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java index 5576360b65..856e30cb90 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java @@ -48,8 +48,8 @@ public final class IntegerTypeEffectiveStatementImpl extends typeDefinition = builder.build(); } catch (InvalidRangeConstraintException e) { final RangeConstraint c = e.getOffendingConstraint(); - throw new SourceException(String.format("Invalid range constraint: <%s, %s>", c.getMin(), c.getMax()), - ctx.getStatementSourceReference(), e); + throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid range constraint: <%s, %s>", + c.getMin(), c.getMax()); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java index 895f14dde1..edbc8dce35 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java @@ -59,8 +59,8 @@ public final class StringTypeEffectiveStatementImpl extends DeclaredEffectiveSta typeDefinition = builder.build(); } catch (InvalidLengthConstraintException e) { final LengthConstraint c = e.getOffendingConstraint(); - throw new SourceException(String.format("Invalid length constraint: <%s, %s>", c.getMin(), c.getMax()), - ctx.getStatementSourceReference(), e); + throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid length constraint: <%s, %s>", + c.getMin(), c.getMax()); } } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/retest/YangParserNegativeTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/retest/YangParserNegativeTest.java index 80ed386a63..cd6e6f5ff5 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/retest/YangParserNegativeTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/retest/YangParserNegativeTest.java @@ -96,8 +96,8 @@ public class YangParserNegativeTest { } catch (SomeModifiersUnresolvedException e) { final Throwable rootCause = Throwables.getRootCause(e); assertTrue(rootCause instanceof InferenceException); - assertTrue(rootCause.getMessage().startsWith("Augment target not found: Absolute{path=[(urn:simple" + - ".container.demo?revision=1970-01-01)unknown]}")); + assertTrue(rootCause.getMessage().startsWith( + "Augment target 'Absolute{path=[(urn:simple.container.demo?revision=1970-01-01)unknown]}' not found")); } } @@ -151,7 +151,7 @@ public class YangParserNegativeTest { fail("SourceException should be thrown"); } } catch (SourceException e) { - String expected = "Error in module 'container': can not add '(urn:simple.container" + + String expected = "Error in module 'container': cannot add '(urn:simple.container" + ".demo?revision=1970-01-01)foo'. Node name collision: '(urn:simple.container" + ".demo?revision=1970-01-01)foo' already declared."; assertTrue(e.getMessage().contains(expected)); @@ -167,7 +167,7 @@ public class YangParserNegativeTest { fail("SourceException should be thrown"); } } catch (SourceException e) { - String expected = "Error in module 'container-list': can not add '(urn:simple.container" + + String expected = "Error in module 'container-list': cannot add '(urn:simple.container" + ".demo?revision=1970-01-01)foo'. Node name collision: '(urn:simple.container" + ".demo?revision=1970-01-01)foo' already declared."; assertTrue(e.getMessage().contains(expected)); @@ -183,7 +183,7 @@ public class YangParserNegativeTest { fail("SourceException should be thrown"); } } catch (SourceException e) { - String expected = "Error in module 'container-leaf': can not add '(urn:simple.container" + + String expected = "Error in module 'container-leaf': cannot add '(urn:simple.container" + ".demo?revision=1970-01-01)foo'. Node name collision: '(urn:simple.container" + ".demo?revision=1970-01-01)foo' already declared."; assertTrue(e.getMessage().contains(expected)); @@ -199,7 +199,7 @@ public class YangParserNegativeTest { fail("SourceException should be thrown"); } } catch (SourceException e) { - String expected = "Error in module 'typedef': can not add '(urn:simple.container" + + String expected = "Error in module 'typedef': cannot add '(urn:simple.container" + ".demo?revision=1970-01-01)int-ext'. Node name collision: '(urn:simple.container" + ".demo?revision=1970-01-01)int-ext' already declared."; assertTrue(e.getMessage().startsWith(expected)); -- 2.36.6