From aae3ec264b796274acca53ddb404f0bdecdace70 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Tue, 18 Oct 2016 02:20:16 +0200 Subject: [PATCH] Reuse cardinality constants 0..1, 0..MAX and 1..1 are common cardinalities. Instead of leaking the MAX constant create additional builder methods which reuse Cardinality objects. Change-Id: Ie11e1f4414c484ecd43f0b472f9df8f0d0c18d0e Signed-off-by: Robert Varga --- .../parser/spi/SubstatementValidator.java | 67 ++++++++++++++++++- .../stmt/rfc6020/AnyxmlStatementImpl.java | 34 +++++----- .../stmt/rfc6020/ArgumentStatementImpl.java | 12 ++-- .../stmt/rfc6020/AugmentStatementImpl.java | 28 ++++---- .../stmt/rfc6020/BelongsToStatementImpl.java | 2 +- .../parser/stmt/rfc6020/BitStatementImpl.java | 18 ++--- .../stmt/rfc6020/BitsSpecificationImpl.java | 6 +- .../stmt/rfc6020/CaseStatementImpl.java | 28 ++++---- .../stmt/rfc6020/ChoiceStatementImpl.java | 42 ++++++------ .../stmt/rfc6020/ContainerStatementImpl.java | 48 +++++++------ .../rfc6020/Decimal64SpecificationImpl.java | 6 +- .../stmt/rfc6020/DeviateStatementImpl.java | 30 ++++----- .../stmt/rfc6020/DeviationStatementImpl.java | 10 ++- .../stmt/rfc6020/EnumSpecificationImpl.java | 14 ++-- .../stmt/rfc6020/EnumStatementImpl.java | 10 +-- .../stmt/rfc6020/ExtensionStatementImpl.java | 8 +-- .../stmt/rfc6020/FeatureStatementImpl.java | 20 +++--- .../stmt/rfc6020/GroupingStatementImpl.java | 36 +++++----- .../rfc6020/IdentityRefSpecificationImpl.java | 14 ++-- .../stmt/rfc6020/IdentityStatementImpl.java | 10 +-- .../rfc6020/ImportStatementDefinition.java | 11 +-- .../stmt/rfc6020/IncludeStatementImpl.java | 3 +- .../stmt/rfc6020/InputStatementImpl.java | 32 +++++---- .../InstanceIdentifierSpecificationImpl.java | 12 ++-- .../stmt/rfc6020/LeafListStatementImpl.java | 38 +++++------ .../stmt/rfc6020/LeafStatementImpl.java | 36 +++++----- .../rfc6020/LeafrefSpecificationImpl.java | 14 ++-- .../stmt/rfc6020/LengthStatementImpl.java | 18 ++--- .../stmt/rfc6020/ListStatementImpl.java | 56 ++++++++-------- .../stmt/rfc6020/ModuleStatementSupport.java | 59 ++++++++-------- .../stmt/rfc6020/MustStatementImpl.java | 10 +-- .../rfc6020/NotificationStatementImpl.java | 40 ++++++----- .../rfc6020/NumericalRestrictionsImpl.java | 4 +- .../stmt/rfc6020/OutputStatementImpl.java | 22 +++--- .../stmt/rfc6020/PatternStatementImpl.java | 10 +-- .../stmt/rfc6020/RangeStatementImpl.java | 18 ++--- .../stmt/rfc6020/RefineStatementImpl.java | 22 +++--- .../stmt/rfc6020/RevisionStatementImpl.java | 4 +- .../parser/stmt/rfc6020/RpcStatementImpl.java | 30 ++++----- .../stmt/rfc6020/StringRestrictionsImpl.java | 16 ++--- .../stmt/rfc6020/SubmoduleStatementImpl.java | 52 +++++++------- .../stmt/rfc6020/TypeStatementImpl.java | 21 +++--- .../stmt/rfc6020/TypedefStatementImpl.java | 12 ++-- .../stmt/rfc6020/UnionSpecificationImpl.java | 14 ++-- .../stmt/rfc6020/UsesStatementImpl.java | 15 ++--- .../stmt/rfc6020/WhenStatementImpl.java | 6 +- 46 files changed, 520 insertions(+), 498 deletions(-) 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 761b60c1f2..48d90fa618 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 @@ -24,7 +24,15 @@ import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName; import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase; public final class SubstatementValidator { + /** + * @deprecated Deprecated since version 1.1.0. Use {@link Builder#addAny(StatementDefinition)}, + * {@link Builder#addAtLeast(StatementDefinition, int)}, + * {@link Builder#addMandatory(StatementDefinition)}, or + * {@link Builder#addMultiple(StatementDefinition)} instead. + */ + @Deprecated public final static int MAX = Integer.MAX_VALUE; + private final Map cardinalityMap; private final StatementDefinition currentStatement; private final SpecialCase specialCase; @@ -40,6 +48,11 @@ public final class SubstatementValidator { } public static class Builder { + private static final Cardinality ONE_MAX = new Cardinality(1, Integer.MAX_VALUE); + private static final Cardinality ONE_ONE = new Cardinality(1, 1); + private static final Cardinality ZERO_MAX = new Cardinality(0, Integer.MAX_VALUE); + private static final Cardinality ZERO_ONE = new Cardinality(0, 1); + private final ImmutableMap.Builder cardinalityMap = ImmutableMap.builder(); private final StatementDefinition currentStatement; @@ -47,11 +60,59 @@ public final class SubstatementValidator { this.currentStatement = currentStatement; } - public Builder add(final StatementDefinition d, final int min, final int max) { - this.cardinalityMap.put(d, new Cardinality(min, max)); + private Builder add(final StatementDefinition d, final Cardinality c) { + cardinalityMap.put(d, c); return this; } + public Builder add(final StatementDefinition d, final int min, final int max) { + if (max == Integer.MAX_VALUE) { + return addAtLeast(d, min); + } else if (min == 0) { + return addAtMost(d, max); + } else { + return add(d, new Cardinality(min, max)); + } + } + + // Equivalent to min .. Integer.MAX_VALUE + public Builder addAtLeast(final StatementDefinition d, final int min) { + switch (min) { + case 0: + return addAny(d); + case 1: + return addMultiple(d); + default: + return add(d, new Cardinality(min, Integer.MAX_VALUE)); + } + } + + // Equivalent to 0 .. max + public Builder addAtMost(final StatementDefinition d, final int max) { + return max == Integer.MAX_VALUE ? addAny(d) : add(d, new Cardinality(0, max)); + } + + + // Equivalent to 0 .. Integer.MAX_VALUE + public Builder addAny(final StatementDefinition d) { + return add(d, ZERO_MAX); + } + + // Equivalent to 1 .. 1 + public Builder addMandatory(final StatementDefinition d) { + return add(d, ONE_ONE); + } + + // Equivalent to 1 .. MAX + public Builder addMultiple(final StatementDefinition d) { + return add(d, ONE_MAX); + } + + // Equivalent to 0 .. 1 + public Builder addOptional(final StatementDefinition d) { + return add(d, ZERO_ONE); + } + public SubstatementValidator build() { return new SubstatementValidator(this, SpecialCase.NULL); } @@ -122,7 +183,7 @@ public final class SubstatementValidator { } } - private static class Cardinality { + private static final class Cardinality { private final int min; private final int max; diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AnyxmlStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AnyxmlStatementImpl.java index db3dc9d211..fe30481bbc 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AnyxmlStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AnyxmlStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import com.google.common.base.Optional; import java.util.Collection; import java.util.Map; @@ -41,18 +39,18 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangModeled public class AnyxmlStatementImpl extends AbstractDeclaredStatement implements AnyxmlStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .ANYXML) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.MANDATORY, 0, 1) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.WHEN, 0, 1) - .add(SupportedExtensionsMapping.ANYXML_SCHEMA_LOCATION, 0, 1) + .addOptional(Rfc6020Mapping.CONFIG) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addOptional(Rfc6020Mapping.MANDATORY) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addOptional(Rfc6020Mapping.WHEN) + .addOptional(SupportedExtensionsMapping.ANYXML_SCHEMA_LOCATION) .build(); - protected AnyxmlStatementImpl(StmtContext context) { + protected AnyxmlStatementImpl(final StmtContext context) { super(context); } @@ -64,17 +62,17 @@ public class AnyxmlStatementImpl extends AbstractDeclaredStatement implem } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override - public void onStatementAdded(Mutable> stmt) { + public void onStatementAdded(final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override - public AnyxmlStatement createDeclared(StmtContext ctx) { + public AnyxmlStatement createDeclared(final StmtContext ctx) { return new AnyxmlStatementImpl(ctx); } @@ -95,15 +93,15 @@ public class AnyxmlStatementImpl extends AbstractDeclaredStatement implem } @Override - public void onFullDefinitionDeclared(Mutable> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); } private Optional getAnyXmlSchema( - StmtContext> ctx, - SchemaNodeIdentifier contentSchemaPath) { + final StmtContext> ctx, + final SchemaNodeIdentifier contentSchemaPath) { final StatementContextBase findNode = Utils.findNode(ctx.getRoot(), contentSchemaPath); if (findNode != null) { final EffectiveStatement anyXmlSchemaNode = findNode.buildEffective(); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ArgumentStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ArgumentStatementImpl.java index 1d7a6b7195..e2fd7af886 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ArgumentStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ArgumentStatementImpl.java @@ -22,11 +22,11 @@ public class ArgumentStatementImpl extends AbstractDeclaredStatement implements ArgumentStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .ARGUMENT) - .add(Rfc6020Mapping.YIN_ELEMENT, 0, 1) + .addOptional(Rfc6020Mapping.YIN_ELEMENT) .build(); protected ArgumentStatementImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -39,24 +39,24 @@ public class ArgumentStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override public ArgumentStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new ArgumentStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new ArgumentEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/AugmentStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java index d6adbe039a..8d2f5e0aeb 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 @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import com.google.common.base.Preconditions; import java.util.Collection; import java.util.regex.Pattern; @@ -42,19 +40,19 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement context) { 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 8863477af5..2627c33e2e 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 @@ -33,7 +33,7 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BelongsEffe public class BelongsToStatementImpl extends AbstractDeclaredStatement implements BelongsToStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = - SubstatementValidator.builder(Rfc6020Mapping.BELONGS_TO).add(Rfc6020Mapping.PREFIX, 1, 1).build(); + SubstatementValidator.builder(Rfc6020Mapping.BELONGS_TO).addMandatory(Rfc6020Mapping.PREFIX).build(); protected BelongsToStatementImpl(final StmtContext context) { super(context); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitStatementImpl.java index 3a9a66afb9..cfff727609 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitStatementImpl.java @@ -24,13 +24,13 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitEff public class BitStatementImpl extends AbstractDeclaredStatement implements BitStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .BIT) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.POSITION, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addOptional(Rfc6020Mapping.POSITION) .build(); - protected BitStatementImpl(StmtContext context) { + protected BitStatementImpl(final StmtContext context) { super(context); } @@ -42,23 +42,23 @@ public class BitStatementImpl extends AbstractDeclaredStatement implement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override - public BitStatement createDeclared(StmtContext ctx) { + public BitStatement createDeclared(final StmtContext ctx) { return new BitStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new BitEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/BitsSpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitsSpecificationImpl.java index 816bdb62c5..055efd2268 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitsSpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BitsSpecificationImpl.java @@ -7,8 +7,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.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -23,7 +21,7 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsSp public class BitsSpecificationImpl extends AbstractDeclaredStatement implements TypeStatement.BitsSpecification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.BIT, 1, MAX) + .addMultiple(Rfc6020Mapping.BIT) .build(); protected BitsSpecificationImpl(final StmtContext context) { @@ -56,7 +54,7 @@ public class BitsSpecificationImpl extends AbstractDeclaredStatement imp } @Override - public void onFullDefinitionDeclared(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/CaseStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/CaseStatementImpl.java index 48a07a5890..a49ce2b8dd 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/CaseStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/CaseStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -32,18 +30,18 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.CaseEffecti public class CaseStatementImpl extends AbstractDeclaredStatement implements CaseStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .CASE) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.USES, 0, MAX) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addAny(Rfc6020Mapping.USES) + .addOptional(Rfc6020Mapping.WHEN) .build(); protected CaseStatementImpl( @@ -77,7 +75,7 @@ public class CaseStatementImpl extends AbstractDeclaredStatement implemen } @Override - public void onFullDefinitionDeclared(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/ChoiceStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ChoiceStatementImpl.java index fc151f32e2..3bb32761a8 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ChoiceStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ChoiceStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -36,23 +34,23 @@ public class ChoiceStatementImpl extends AbstractDeclaredStatement implements ChoiceStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .CHOICE) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CASE, 0, MAX) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DEFAULT, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.MANDATORY, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CASE) + .addOptional(Rfc6020Mapping.CONFIG) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DEFAULT) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addOptional(Rfc6020Mapping.MANDATORY) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addOptional(Rfc6020Mapping.WHEN) .build(); - protected ChoiceStatementImpl(StmtContext context) { + protected ChoiceStatementImpl(final StmtContext context) { super(context); } @@ -65,29 +63,29 @@ public class ChoiceStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override - public void onStatementAdded(Mutable> stmt) { + public void onStatementAdded(final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override public ChoiceStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new ChoiceStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new ChoiceEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/ContainerStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ContainerStatementImpl.java index 475949f014..7c4d847323 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ContainerStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ContainerStatementImpl.java @@ -7,8 +7,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; @@ -35,26 +33,26 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEf public class ContainerStatementImpl extends AbstractDeclaredStatement implements ContainerStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .CONTAINER) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.PRESENCE, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addOptional(Rfc6020Mapping.CONFIG) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.PRESENCE) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) + .addOptional(Rfc6020Mapping.WHEN) .build(); - protected ContainerStatementImpl(StmtContext context) { + protected ContainerStatementImpl(final StmtContext context) { super(context); } @@ -65,28 +63,28 @@ public class ContainerStatementImpl extends AbstractDeclaredStatement imp } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx,value); } @Override public void onStatementAdded( - Mutable> stmt) { + final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override - public ContainerStatement createDeclared(StmtContext ctx) { + public ContainerStatement createDeclared(final StmtContext ctx) { return new ContainerStatementImpl(ctx); } @Override - public EffectiveStatement createEffective(StmtContext> ctx) { + public EffectiveStatement createEffective(final StmtContext> ctx) { return new ContainerEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/Decimal64SpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Decimal64SpecificationImpl.java index 7aab5c1a66..0b46a69aac 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Decimal64SpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Decimal64SpecificationImpl.java @@ -21,8 +21,8 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Decima public class Decimal64SpecificationImpl extends AbstractDeclaredStatement implements Decimal64Specification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.FRACTION_DIGITS, 1, 1) - .add(Rfc6020Mapping.RANGE, 0, 1) + .addMandatory(Rfc6020Mapping.FRACTION_DIGITS) + .addOptional(Rfc6020Mapping.RANGE) .build(); protected Decimal64SpecificationImpl(final StmtContext context) { @@ -53,7 +53,7 @@ public class Decimal64SpecificationImpl extends AbstractDeclaredStatement> 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/DeviateStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java index 6aaa6fba27..6a4b91e0c7 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.DeviateKind; import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; @@ -23,18 +21,18 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviateEffe public class DeviateStatementImpl extends AbstractDeclaredStatement implements DeviateStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .DEVIATE) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.DEFAULT, 0, 1) - .add(Rfc6020Mapping.MANDATORY, 0, 1) - .add(Rfc6020Mapping.MAX_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MIN_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.TYPE, 0, 1) - .add(Rfc6020Mapping.UNIQUE, 0, MAX) - .add(Rfc6020Mapping.UNITS, 0, 1) + .addOptional(Rfc6020Mapping.CONFIG) + .addOptional(Rfc6020Mapping.DEFAULT) + .addOptional(Rfc6020Mapping.MANDATORY) + .addOptional(Rfc6020Mapping.MAX_ELEMENTS) + .addOptional(Rfc6020Mapping.MIN_ELEMENTS) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.TYPE) + .addAny(Rfc6020Mapping.UNIQUE) + .addOptional(Rfc6020Mapping.UNITS) .build(); - protected DeviateStatementImpl(StmtContext context) { + protected DeviateStatementImpl(final StmtContext context) { super(context); } @@ -45,22 +43,22 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement super(Rfc6020Mapping.DEVIATE); } - @Override public DeviateKind parseArgumentValue(StmtContext ctx, String value) { + @Override public DeviateKind parseArgumentValue(final StmtContext ctx, final String value) { return Utils.parseDeviateFromString(ctx, value); } - @Override public DeviateStatement createDeclared(StmtContext ctx) { + @Override public DeviateStatement createDeclared(final StmtContext ctx) { return new DeviateStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { return new DeviateEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/DeviationStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviationStatementImpl.java index 7ea5a5760d..82589ef59d 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviationStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviationStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -23,9 +21,9 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviationEf public class DeviationStatementImpl extends AbstractDeclaredStatement implements DeviationStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .DEVIATION) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.DEVIATE, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.DEVIATE) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); protected DeviationStatementImpl(final StmtContext context) { @@ -55,7 +53,7 @@ public class DeviationStatementImpl extends AbstractDeclaredStatement> 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/EnumSpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/EnumSpecificationImpl.java index deb6339754..05f6ea41bd 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/EnumSpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/EnumSpecificationImpl.java @@ -7,8 +7,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.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -23,10 +21,10 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumSp public class EnumSpecificationImpl extends AbstractDeclaredStatement implements TypeStatement.EnumSpecification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.ENUM, 1, MAX) + .addMultiple(Rfc6020Mapping.ENUM) .build(); - protected EnumSpecificationImpl(StmtContext context) { + protected EnumSpecificationImpl(final StmtContext context) { super(context); } @@ -39,24 +37,24 @@ public class EnumSpecificationImpl extends AbstractDeclaredStatement imp } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public TypeStatement.EnumSpecification createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new EnumSpecificationImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new EnumSpecificationEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/EnumStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/EnumStatementImpl.java index 4809d7cbcf..825990af73 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/EnumStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/EnumStatementImpl.java @@ -23,10 +23,10 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumEf public class EnumStatementImpl extends AbstractDeclaredStatement implements EnumStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .ENUM) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.VALUE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addOptional(Rfc6020Mapping.VALUE) .build(); protected EnumStatementImpl(final StmtContext context) { @@ -58,7 +58,7 @@ public class EnumStatementImpl extends AbstractDeclaredStatement impleme } @Override - public void onFullDefinitionDeclared(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/ExtensionStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ExtensionStatementImpl.java index ebcbc5b189..6ac35b5628 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ExtensionStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ExtensionStatementImpl.java @@ -25,10 +25,10 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtensionEf public class ExtensionStatementImpl extends AbstractDeclaredStatement implements ExtensionStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .EXTENSION) - .add(Rfc6020Mapping.ARGUMENT, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) + .addOptional(Rfc6020Mapping.ARGUMENT) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) .build(); protected ExtensionStatementImpl(final StmtContext context) { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/FeatureStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/FeatureStatementImpl.java index 29578ae775..d03b4017af 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/FeatureStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/FeatureStatementImpl.java @@ -7,8 +7,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; @@ -28,14 +26,14 @@ public class FeatureStatementImpl extends AbstractDeclaredStatement implements FeatureStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .FEATURE) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addOptional(Rfc6020Mapping.STATUS) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); protected FeatureStatementImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -48,24 +46,24 @@ public class FeatureStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override public FeatureStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new FeatureStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new FeatureEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/GroupingStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingStatementImpl.java index df1be54756..4960b96519 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/GroupingStatementImpl.java @@ -7,8 +7,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; @@ -31,22 +29,22 @@ public class GroupingStatementImpl extends AbstractDeclaredStatement implements GroupingStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .GROUPING) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) .build(); protected GroupingStatementImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -59,24 +57,24 @@ public class GroupingStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override public GroupingStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new GroupingStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new GroupingEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(Mutable> stmt) { SUBSTATEMENT_VALIDATOR.validate(stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityRefSpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityRefSpecificationImpl.java index 2deb59dc92..ef813f1f4c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityRefSpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityRefSpecificationImpl.java @@ -26,11 +26,11 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Identi public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement implements TypeStatement.IdentityRefSpecification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.BASE, 1, 1) + .addMandatory(Rfc6020Mapping.BASE) .build(); protected IdentityRefSpecificationImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -43,25 +43,25 @@ public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public TypeStatement.IdentityRefSpecification createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new IdentityRefSpecificationImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { return new IdentityRefSpecificationEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable> stmt) { final StmtContext baseStmt = StmtContextUtils.findFirstDeclaredSubstatement(stmt, BaseStatement.class); @@ -77,7 +77,7 @@ public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement> stmt) { super.onStatementDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityStatementImpl.java index 2b31fe726b..47ef21751d 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IdentityStatementImpl.java @@ -26,10 +26,10 @@ public class IdentityStatementImpl extends AbstractDeclaredStatement implements IdentityStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .IDENTITY) - .add(Rfc6020Mapping.BASE, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) + .addOptional(Rfc6020Mapping.BASE) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) .build(); protected IdentityStatementImpl( @@ -66,7 +66,7 @@ public class IdentityStatementImpl extends AbstractDeclaredStatement } @Override - public void onFullDefinitionDeclared(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/ImportStatementDefinition.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java index 336b85cb1a..00b14b4b7e 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 @@ -53,8 +53,11 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ImportEffec 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) - .add(SupportedExtensionsMapping.SEMANTIC_VERSION, 0, 1).build(); + .builder(Rfc6020Mapping.IMPORT) + .addMandatory(Rfc6020Mapping.PREFIX) + .addOptional(Rfc6020Mapping.REVISION_DATE) + .addOptional(SupportedExtensionsMapping.SEMANTIC_VERSION) + .build(); public ImportStatementDefinition() { super(Rfc6020Mapping.IMPORT); @@ -84,7 +87,7 @@ public class ImportStatementDefinition extends } @Override - public void onPreLinkageDeclared(Mutable> stmt) { + public void onPreLinkageDeclared(final Mutable> stmt) { final String moduleName = stmt.getStatementArgument(); final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE); final Prerequisite> imported = importAction.requiresCtx(stmt, @@ -261,7 +264,7 @@ public class ImportStatementDefinition extends }); } - private static SemVer getRequestedImportVersion(Mutable impStmt) { + private static SemVer getRequestedImportVersion(final Mutable impStmt) { SemVer requestedImportVersion = impStmt.getFromNamespace(SemanticVersionNamespace.class, impStmt); if (requestedImportVersion == null) { requestedImportVersion = Module.DEFAULT_SEMANTIC_VERSION; 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 ea2c5f7b5c..8aedce9d0e 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,6 +9,7 @@ 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.util.Collection; import java.util.Date; @@ -35,7 +36,7 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IncludeEffe public class IncludeStatementImpl extends AbstractDeclaredStatement implements IncludeStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder( - Rfc6020Mapping.INCLUDE).add(Rfc6020Mapping.REVISION_DATE, 0, 1).build(); + Rfc6020Mapping.INCLUDE).addOptional(Rfc6020Mapping.REVISION_DATE).build(); protected IncludeStatementImpl(final StmtContext context) { super(context); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InputStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InputStatementImpl.java index 23f2547c87..56287d22a3 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InputStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InputStatementImpl.java @@ -7,8 +7,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; @@ -28,18 +26,18 @@ public class InputStatementImpl extends AbstractDeclaredStatement implements InputStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .INPUT) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addAny(Rfc6020Mapping.CONTAINER) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) .build(); - protected InputStatementImpl(StmtContext context) { + protected InputStatementImpl(final StmtContext context) { super(context); } @@ -52,29 +50,29 @@ public class InputStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, "input"); } @Override - public void onStatementAdded(Mutable> stmt) { + public void onStatementAdded(final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override public InputStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new InputStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new InputEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/InstanceIdentifierSpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InstanceIdentifierSpecificationImpl.java index fd2195e4a3..e6fce24f09 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InstanceIdentifierSpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/InstanceIdentifierSpecificationImpl.java @@ -22,11 +22,11 @@ public class InstanceIdentifierSpecificationImpl extends TypeStatement.InstanceIdentifierSpecification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.REQUIRE_INSTANCE, 0, 1) + .addOptional(Rfc6020Mapping.REQUIRE_INSTANCE) .build(); protected InstanceIdentifierSpecificationImpl( - StmtContext ctx) { + final StmtContext ctx) { super(ctx); } @@ -39,24 +39,24 @@ public class InstanceIdentifierSpecificationImpl extends } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public TypeStatement.InstanceIdentifierSpecification createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new InstanceIdentifierSpecificationImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new InstanceIdentifierSpecificationEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/LeafListStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafListStatementImpl.java index 2f0d688c26..572d395982 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafListStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafListStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -39,22 +37,22 @@ public class LeafListStatementImpl extends AbstractDeclaredStatement implements LeafListStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .LEAF_LIST) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.MIN_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MAX_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.ORDERED_BY, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPE, 1, 1) - .add(Rfc6020Mapping.UNITS, 0, 1) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addOptional(Rfc6020Mapping.CONFIG) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addOptional(Rfc6020Mapping.MIN_ELEMENTS) + .addOptional(Rfc6020Mapping.MAX_ELEMENTS) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.ORDERED_BY) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addMandatory(Rfc6020Mapping.TYPE) + .addOptional(Rfc6020Mapping.UNITS) + .addOptional(Rfc6020Mapping.WHEN) .build(); protected LeafListStatementImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -68,30 +66,30 @@ public class LeafListStatementImpl extends AbstractDeclaredStatement @Override public void onStatementAdded( - Mutable> stmt) { + final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override - public QName parseArgumentValue(StmtContext ctx, String value) + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override public LeafListStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new LeafListStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new LeafListEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/LeafStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafStatementImpl.java index 0594c7ea2b..ff24172df8 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -37,20 +35,20 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffecti public class LeafStatementImpl extends AbstractDeclaredStatement implements LeafStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .LEAF) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.DEFAULT, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.MANDATORY, 0, 1) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPE, 1, 1) - .add(Rfc6020Mapping.UNITS, 0, 1) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addOptional(Rfc6020Mapping.CONFIG) + .addOptional(Rfc6020Mapping.DEFAULT) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addOptional(Rfc6020Mapping.MANDATORY) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addMandatory(Rfc6020Mapping.TYPE) + .addOptional(Rfc6020Mapping.UNITS) + .addOptional(Rfc6020Mapping.WHEN) .build(); - protected LeafStatementImpl(StmtContext context) { + protected LeafStatementImpl(final StmtContext context) { super(context); } @@ -60,27 +58,27 @@ public class LeafStatementImpl extends AbstractDeclaredStatement implemen super(Rfc6020Mapping.LEAF); } - @Override public QName parseArgumentValue(StmtContext ctx, String value) { + @Override public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx,value); } @Override - public void onStatementAdded(Mutable> stmt) { + public void onStatementAdded(final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override public LeafStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new LeafStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new LeafEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/LeafrefSpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafrefSpecificationImpl.java index c5dd0af72c..eb4ab7b415 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafrefSpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LeafrefSpecificationImpl.java @@ -21,12 +21,12 @@ public class LeafrefSpecificationImpl extends AbstractDeclaredStatement implements TypeStatement.LeafrefSpecification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.PATH, 1, 1) - .add(Rfc6020Mapping.REQUIRE_INSTANCE, 0, 1) + .addMandatory(Rfc6020Mapping.PATH) + .addOptional(Rfc6020Mapping.REQUIRE_INSTANCE) .build(); protected LeafrefSpecificationImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -39,24 +39,24 @@ public class LeafrefSpecificationImpl extends AbstractDeclaredStatement } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public TypeStatement.LeafrefSpecification createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new LeafrefSpecificationImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new LeafrefSpecificationEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/LengthStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LengthStatementImpl.java index a8fc152e54..8e4d95c4fa 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LengthStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/LengthStatementImpl.java @@ -25,13 +25,13 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Length public class LengthStatementImpl extends AbstractDeclaredStatement> implements LengthStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .LENGTH) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.ERROR_APP_TAG, 0, 1) - .add(Rfc6020Mapping.ERROR_MESSAGE, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.ERROR_APP_TAG) + .addOptional(Rfc6020Mapping.ERROR_MESSAGE) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); - protected LengthStatementImpl(StmtContext, LengthStatement, ?> context) { + protected LengthStatementImpl(final StmtContext, LengthStatement, ?> context) { super(context); } @@ -43,24 +43,24 @@ public class LengthStatementImpl extends AbstractDeclaredStatement parseArgumentValue(StmtContext ctx, String value) { + public List parseArgumentValue(final StmtContext ctx, final String value) { return TypeUtils.parseLengthListFromString(ctx, value); } @Override - public LengthStatement createDeclared(StmtContext, LengthStatement, ?> ctx) { + public LengthStatement createDeclared(final StmtContext, LengthStatement, ?> ctx) { return new LengthStatementImpl(ctx); } @Override public EffectiveStatement, LengthStatement> createEffective( - StmtContext, LengthStatement, EffectiveStatement, + final StmtContext, LengthStatement, EffectiveStatement, LengthStatement>> ctx) { return new LengthEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable, + public void onFullDefinitionDeclared(final StmtContext.Mutable, LengthStatement, EffectiveStatement, LengthStatement>> 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/ListStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ListStatementImpl.java index 3e5a84c332..d1ac724078 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ListStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ListStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -42,30 +40,30 @@ public class ListStatementImpl extends AbstractDeclaredStatement implements ListStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .LIST) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.KEY, 0, 1) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.MAX_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MIN_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.ORDERED_BY, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.UNIQUE, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addOptional(Rfc6020Mapping.CONFIG) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addOptional(Rfc6020Mapping.KEY) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addOptional(Rfc6020Mapping.MAX_ELEMENTS) + .addOptional(Rfc6020Mapping.MIN_ELEMENTS) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.ORDERED_BY) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.UNIQUE) + .addAny(Rfc6020Mapping.USES) + .addOptional(Rfc6020Mapping.WHEN) .build(); - protected ListStatementImpl(StmtContext context) { + protected ListStatementImpl(final StmtContext context) { super(context); } @@ -78,29 +76,29 @@ public class ListStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override - public void onStatementAdded(Mutable> stmt) { + public void onStatementAdded(final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override public ListStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new ListStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new ListEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/ModuleStatementSupport.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ModuleStatementSupport.java index 255fdd337e..591e88d8b2 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 @@ -7,7 +7,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; @@ -52,33 +51,33 @@ public class ModuleStatementSupport extends AbstractStatementSupport> { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .MODULE) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.AUGMENT, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTACT, 0, 1) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.DEVIATION, 0, MAX) - .add(Rfc6020Mapping.EXTENSION, 0, MAX) - .add(Rfc6020Mapping.FEATURE, 0, MAX) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.IDENTITY, 0, MAX) - .add(Rfc6020Mapping.IMPORT, 0, MAX) - .add(Rfc6020Mapping.INCLUDE, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.NAMESPACE, 1, 1) - .add(Rfc6020Mapping.NOTIFICATION, 0, MAX) - .add(Rfc6020Mapping.ORGANIZATION, 0, 1) - .add(Rfc6020Mapping.PREFIX, 1, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.REVISION, 0, MAX) - .add(Rfc6020Mapping.RPC, 0, MAX) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) - .add(Rfc6020Mapping.YANG_VERSION, 0, 1) - .add(SupportedExtensionsMapping.SEMANTIC_VERSION, 0, 1) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.AUGMENT) + .addAny(Rfc6020Mapping.CHOICE) + .addOptional(Rfc6020Mapping.CONTACT) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.DEVIATION) + .addAny(Rfc6020Mapping.EXTENSION) + .addAny(Rfc6020Mapping.FEATURE) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.IDENTITY) + .addAny(Rfc6020Mapping.IMPORT) + .addAny(Rfc6020Mapping.INCLUDE) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addMandatory(Rfc6020Mapping.NAMESPACE) + .addAny(Rfc6020Mapping.NOTIFICATION) + .addOptional(Rfc6020Mapping.ORGANIZATION) + .addMandatory(Rfc6020Mapping.PREFIX) + .addOptional(Rfc6020Mapping.REFERENCE) + .addAny(Rfc6020Mapping.REVISION) + .addAny(Rfc6020Mapping.RPC) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) + .addOptional(Rfc6020Mapping.YANG_VERSION) + .addOptional(SupportedExtensionsMapping.SEMANTIC_VERSION) .build(); public ModuleStatementSupport() { @@ -102,7 +101,7 @@ public class ModuleStatementSupport extends } @Override - public void onPreLinkageDeclared(Mutable> stmt) { + public void onPreLinkageDeclared(final Mutable> stmt) { final String moduleName = stmt.getStatementArgument(); final URI moduleNs = firstAttributeOf(stmt.declaredSubstatements(), @@ -173,7 +172,7 @@ public class ModuleStatementSupport extends NavigableMap> modulesMap = stmt.getFromNamespace( SemanticVersionModuleNamespace.class, moduleName); if (modulesMap == null) { - modulesMap = new TreeMap>(); + modulesMap = new TreeMap<>(); } SemVer moduleSemVer = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt); if(moduleSemVer == null) { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/MustStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/MustStatementImpl.java index 26dff12995..a36c858fe4 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/MustStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/MustStatementImpl.java @@ -26,10 +26,10 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MustEffecti public class MustStatementImpl extends AbstractDeclaredStatement implements MustStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .MUST) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.ERROR_APP_TAG, 0, 1) - .add(Rfc6020Mapping.ERROR_MESSAGE, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.ERROR_APP_TAG) + .addOptional(Rfc6020Mapping.ERROR_MESSAGE) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); protected MustStatementImpl(final StmtContext context) { @@ -60,7 +60,7 @@ public class MustStatementImpl extends AbstractDeclaredStatement> 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/NotificationStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/NotificationStatementImpl.java index 2000d198ca..c5b5cff234 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/NotificationStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/NotificationStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QName; @@ -32,23 +30,23 @@ public class NotificationStatementImpl extends AbstractDeclaredStatement implements NotificationStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .NOTIFICATION) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) .build(); protected NotificationStatementImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -61,30 +59,30 @@ public class NotificationStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override public void onStatementAdded( - Mutable> stmt) { + final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override public NotificationStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new NotificationStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new NotificationEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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/NumericalRestrictionsImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/NumericalRestrictionsImpl.java index 0fe45c64dc..5e8421a3a1 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/NumericalRestrictionsImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/NumericalRestrictionsImpl.java @@ -21,7 +21,7 @@ public class NumericalRestrictionsImpl extends AbstractDeclaredStatement TypeStatement.NumericalRestrictions { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.RANGE, 1, 1) + .addMandatory(Rfc6020Mapping.RANGE) .build(); protected NumericalRestrictionsImpl(final StmtContext context) { @@ -53,7 +53,7 @@ public class NumericalRestrictionsImpl extends AbstractDeclaredStatement } @Override - public void onFullDefinitionDeclared(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/OutputStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/OutputStatementImpl.java index 2da48c8391..150d08412a 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/OutputStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/OutputStatementImpl.java @@ -7,8 +7,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; @@ -27,15 +25,15 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffec public class OutputStatementImpl extends AbstractDeclaredStatement implements OutputStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .OUTPUT) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.CHOICE) + .addAny(Rfc6020Mapping.CONTAINER) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) .build(); protected OutputStatementImpl(final StmtContext context) { @@ -71,7 +69,7 @@ public class OutputStatementImpl extends AbstractDeclaredStatement implem } @Override - public void onFullDefinitionDeclared(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/PatternStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/PatternStatementImpl.java index 8e43278b36..65508fa762 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/PatternStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/PatternStatementImpl.java @@ -30,10 +30,10 @@ import org.slf4j.LoggerFactory; public class PatternStatementImpl extends AbstractDeclaredStatement implements PatternStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .PATTERN) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.ERROR_APP_TAG, 0, 1) - .add(Rfc6020Mapping.ERROR_MESSAGE, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.ERROR_APP_TAG) + .addOptional(Rfc6020Mapping.ERROR_MESSAGE) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); private static final Logger LOG = LoggerFactory.getLogger(PatternStatementImpl.class); @@ -75,7 +75,7 @@ public class PatternStatementImpl extends AbstractDeclaredStatement> 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/RangeStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RangeStatementImpl.java index ef7c0c8e2c..c91395b008 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RangeStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RangeStatementImpl.java @@ -26,10 +26,10 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.RangeE public class RangeStatementImpl extends AbstractDeclaredStatement> implements RangeStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .RANGE) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.ERROR_APP_TAG, 0, 1) - .add(Rfc6020Mapping.ERROR_MESSAGE, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.ERROR_APP_TAG) + .addOptional(Rfc6020Mapping.ERROR_MESSAGE) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); // these objects are to compare whether range has MAX or MIN value @@ -37,7 +37,7 @@ public class RangeStatementImpl extends AbstractDeclaredStatement, RangeStatement, ?> context) { + protected RangeStatementImpl(final StmtContext, RangeStatement, ?> context) { super(context); } @@ -49,24 +49,24 @@ public class RangeStatementImpl extends AbstractDeclaredStatement parseArgumentValue(StmtContext ctx, String value) { + public List parseArgumentValue(final StmtContext ctx, final String value) { return TypeUtils.parseRangeListFromString(ctx, value); } @Override - public RangeStatement createDeclared(StmtContext, RangeStatement, ?> ctx) { + public RangeStatement createDeclared(final StmtContext, RangeStatement, ?> ctx) { return new RangeStatementImpl(ctx); } @Override public EffectiveStatement, RangeStatement> createEffective( - StmtContext, RangeStatement, EffectiveStatement, + final StmtContext, RangeStatement, EffectiveStatement, RangeStatement>> ctx) { return new RangeEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable, RangeStatement, + public void onFullDefinitionDeclared(final StmtContext.Mutable, RangeStatement, EffectiveStatement, RangeStatement>> 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/RefineStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RefineStatementImpl.java index e7c2668f77..cd474df4af 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RefineStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RefineStatementImpl.java @@ -8,8 +8,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -26,15 +24,15 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RefineEffec public class RefineStatementImpl extends AbstractDeclaredStatement implements RefineStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .REFINE) - .add(Rfc6020Mapping.DEFAULT, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.CONFIG, 0, 1) - .add(Rfc6020Mapping.MANDATORY, 0, 1) - .add(Rfc6020Mapping.PRESENCE, 0, 1) - .add(Rfc6020Mapping.MUST, 0, MAX) - .add(Rfc6020Mapping.MIN_ELEMENTS, 0, 1) - .add(Rfc6020Mapping.MAX_ELEMENTS, 0, 1) + .addOptional(Rfc6020Mapping.DEFAULT) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.CONFIG) + .addOptional(Rfc6020Mapping.MANDATORY) + .addOptional(Rfc6020Mapping.PRESENCE) + .addAny(Rfc6020Mapping.MUST) + .addOptional(Rfc6020Mapping.MIN_ELEMENTS) + .addOptional(Rfc6020Mapping.MAX_ELEMENTS) .build(); protected RefineStatementImpl(final StmtContext context) { @@ -65,7 +63,7 @@ public class RefineStatementImpl extends AbstractDeclaredStatement> 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/RevisionStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RevisionStatementImpl.java index 5ac7643521..ffa0765aec 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 @@ -27,7 +27,9 @@ 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(); + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .build(); protected RevisionStatementImpl(final StmtContext context) { super(context); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RpcStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RpcStatementImpl.java index 1a3006a6e2..e43908b6d7 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RpcStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/RpcStatementImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; -import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX; - import java.util.Collection; import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QName; @@ -34,17 +32,17 @@ public class RpcStatementImpl extends AbstractDeclaredStatement implements RpcStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .RPC) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.INPUT, 0, 1) - .add(Rfc6020Mapping.OUTPUT, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addOptional(Rfc6020Mapping.INPUT) + .addOptional(Rfc6020Mapping.OUTPUT) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addAny(Rfc6020Mapping.TYPEDEF) .build(); - protected RpcStatementImpl(StmtContext context) { + protected RpcStatementImpl(final StmtContext context) { super(context); } @@ -57,29 +55,29 @@ public class RpcStatementImpl extends AbstractDeclaredStatement } @Override - public QName parseArgumentValue(StmtContext ctx, String value) { + public QName parseArgumentValue(final StmtContext ctx, final String value) { return Utils.qNameFromArgument(ctx, value); } @Override - public void onStatementAdded(Mutable> stmt) { + public void onStatementAdded(final Mutable> stmt) { stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt); } @Override public RpcStatement createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new RpcStatementImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new RpcEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(Mutable> stmt) { + 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/StringRestrictionsImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/StringRestrictionsImpl.java index 58a55cd70a..b57bf59c80 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/StringRestrictionsImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/StringRestrictionsImpl.java @@ -7,8 +7,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.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -25,11 +23,11 @@ public class StringRestrictionsImpl extends AbstractDeclaredStatement im TypeStatement.StringRestrictions { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.LENGTH, 0, 1) - .add(Rfc6020Mapping.PATTERN, 0, MAX) + .addOptional(Rfc6020Mapping.LENGTH) + .addAny(Rfc6020Mapping.PATTERN) .build(); - protected StringRestrictionsImpl(StmtContext context) { + protected StringRestrictionsImpl(final StmtContext context) { super(context); } @@ -42,24 +40,24 @@ public class StringRestrictionsImpl extends AbstractDeclaredStatement im } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public TypeStatement.StringRestrictions createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new StringRestrictionsImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new StringRestrictionsEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(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 df31b95d4d..c009a7fe6c 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 @@ -7,9 +7,9 @@ */ 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.util.Date; import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil; @@ -33,31 +33,31 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.SubmoduleEf public class SubmoduleStatementImpl extends AbstractRootStatement implements SubmoduleStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .SUBMODULE) - .add(Rfc6020Mapping.ANYXML, 0, MAX) - .add(Rfc6020Mapping.AUGMENT, 0, MAX) - .add(Rfc6020Mapping.BELONGS_TO, 1, 1) - .add(Rfc6020Mapping.CHOICE, 0, MAX) - .add(Rfc6020Mapping.CONTACT, 0, 1) - .add(Rfc6020Mapping.CONTAINER, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.DEVIATION, 0, MAX) - .add(Rfc6020Mapping.EXTENSION, 0, MAX) - .add(Rfc6020Mapping.FEATURE, 0, MAX) - .add(Rfc6020Mapping.GROUPING, 0, MAX) - .add(Rfc6020Mapping.IDENTITY, 0, MAX) - .add(Rfc6020Mapping.IMPORT, 0, MAX) - .add(Rfc6020Mapping.INCLUDE, 0, MAX) - .add(Rfc6020Mapping.LEAF, 0, MAX) - .add(Rfc6020Mapping.LEAF_LIST, 0, MAX) - .add(Rfc6020Mapping.LIST, 0, MAX) - .add(Rfc6020Mapping.NOTIFICATION, 0, MAX) - .add(Rfc6020Mapping.ORGANIZATION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.REVISION, 0, MAX) - .add(Rfc6020Mapping.RPC, 0, MAX) - .add(Rfc6020Mapping.TYPEDEF, 0, MAX) - .add(Rfc6020Mapping.USES, 0, MAX) - .add(Rfc6020Mapping.YANG_VERSION, 0, 1) + .addAny(Rfc6020Mapping.ANYXML) + .addAny(Rfc6020Mapping.AUGMENT) + .addMandatory(Rfc6020Mapping.BELONGS_TO) + .addAny(Rfc6020Mapping.CHOICE) + .addOptional(Rfc6020Mapping.CONTACT) + .addAny(Rfc6020Mapping.CONTAINER) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.DEVIATION) + .addAny(Rfc6020Mapping.EXTENSION) + .addAny(Rfc6020Mapping.FEATURE) + .addAny(Rfc6020Mapping.GROUPING) + .addAny(Rfc6020Mapping.IDENTITY) + .addAny(Rfc6020Mapping.IMPORT) + .addAny(Rfc6020Mapping.INCLUDE) + .addAny(Rfc6020Mapping.LEAF) + .addAny(Rfc6020Mapping.LEAF_LIST) + .addAny(Rfc6020Mapping.LIST) + .addAny(Rfc6020Mapping.NOTIFICATION) + .addOptional(Rfc6020Mapping.ORGANIZATION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addAny(Rfc6020Mapping.REVISION) + .addAny(Rfc6020Mapping.RPC) + .addAny(Rfc6020Mapping.TYPEDEF) + .addAny(Rfc6020Mapping.USES) + .addOptional(Rfc6020Mapping.YANG_VERSION) .build(); private static final Optional DEFAULT_REVISION = Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_REV); 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 ba3bbb982e..758f6c1343 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 @@ -7,7 +7,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; @@ -64,16 +63,16 @@ public class TypeStatementImpl extends AbstractDeclaredStatement implements TypeStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.BASE, 0, 1) - .add(Rfc6020Mapping.BIT, 0, MAX) - .add(Rfc6020Mapping.ENUM, 0, MAX) - .add(Rfc6020Mapping.FRACTION_DIGITS, 0, 1) - .add(Rfc6020Mapping.LENGTH, 0, 1) - .add(Rfc6020Mapping.PATH, 0, 1) - .add(Rfc6020Mapping.PATTERN, 0, MAX) - .add(Rfc6020Mapping.RANGE, 0, 1) - .add(Rfc6020Mapping.REQUIRE_INSTANCE, 0, 1) - .add(Rfc6020Mapping.TYPE, 0, MAX) + .addOptional(Rfc6020Mapping.BASE) + .addAny(Rfc6020Mapping.BIT) + .addAny(Rfc6020Mapping.ENUM) + .addOptional(Rfc6020Mapping.FRACTION_DIGITS) + .addOptional(Rfc6020Mapping.LENGTH) + .addOptional(Rfc6020Mapping.PATH) + .addAny(Rfc6020Mapping.PATTERN) + .addOptional(Rfc6020Mapping.RANGE) + .addOptional(Rfc6020Mapping.REQUIRE_INSTANCE) + .addAny(Rfc6020Mapping.TYPE) .build(); protected TypeStatementImpl(final StmtContext context) { 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 0d845ca773..726214bbd0 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 @@ -29,12 +29,12 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.TypeDefEffe public class TypedefStatementImpl extends AbstractDeclaredStatement implements TypedefStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPEDEF) - .add(Rfc6020Mapping.DEFAULT, 0, 1) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.TYPE, 1, 1) - .add(Rfc6020Mapping.UNITS, 0, 1) + .addOptional(Rfc6020Mapping.DEFAULT) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addMandatory(Rfc6020Mapping.TYPE) + .addOptional(Rfc6020Mapping.UNITS) .build(); protected TypedefStatementImpl(final StmtContext context) { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UnionSpecificationImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UnionSpecificationImpl.java index a3c501b791..d9a51f9793 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UnionSpecificationImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UnionSpecificationImpl.java @@ -7,8 +7,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.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -23,11 +21,11 @@ public class UnionSpecificationImpl extends AbstractDeclaredStatement implements TypeStatement.UnionSpecification { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .TYPE) - .add(Rfc6020Mapping.TYPE, 1, MAX) + .addMultiple(Rfc6020Mapping.TYPE) .build(); protected UnionSpecificationImpl( - StmtContext context) { + final StmtContext context) { super(context); } @@ -38,24 +36,24 @@ public class UnionSpecificationImpl extends AbstractDeclaredStatement } @Override - public String parseArgumentValue(StmtContext ctx, String value) { + public String parseArgumentValue(final StmtContext ctx, final String value) { return value; } @Override public TypeStatement.UnionSpecification createDeclared( - StmtContext ctx) { + final StmtContext ctx) { return new UnionSpecificationImpl(ctx); } @Override public EffectiveStatement createEffective( - StmtContext> ctx) { + final StmtContext> ctx) { return new UnionSpecificationEffectiveStatementImpl(ctx); } @Override - public void onFullDefinitionDeclared(StmtContext.Mutable> stmt) { + 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/UsesStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java index 92083c435e..7ad0114de9 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 @@ -7,7 +7,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; @@ -41,13 +40,13 @@ import org.slf4j.LoggerFactory; public class UsesStatementImpl extends AbstractDeclaredStatement implements UsesStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .USES) - .add(Rfc6020Mapping.AUGMENT, 0, MAX) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.IF_FEATURE, 0, MAX) - .add(Rfc6020Mapping.REFINE, 0, MAX) - .add(Rfc6020Mapping.REFERENCE, 0, 1) - .add(Rfc6020Mapping.STATUS, 0, 1) - .add(Rfc6020Mapping.WHEN, 0, 1) + .addAny(Rfc6020Mapping.AUGMENT) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addAny(Rfc6020Mapping.IF_FEATURE) + .addAny(Rfc6020Mapping.REFINE) + .addOptional(Rfc6020Mapping.REFERENCE) + .addOptional(Rfc6020Mapping.STATUS) + .addOptional(Rfc6020Mapping.WHEN) .build(); private static final Logger LOG = LoggerFactory.getLogger(UsesStatementImpl.class); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/WhenStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/WhenStatementImpl.java index 573ef225b3..6521c56eb1 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/WhenStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/WhenStatementImpl.java @@ -24,8 +24,8 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.WhenEffecti public class WhenStatementImpl extends AbstractDeclaredStatement implements WhenStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping .WHEN) - .add(Rfc6020Mapping.DESCRIPTION, 0, 1) - .add(Rfc6020Mapping.REFERENCE, 0, 1) + .addOptional(Rfc6020Mapping.DESCRIPTION) + .addOptional(Rfc6020Mapping.REFERENCE) .build(); protected WhenStatementImpl(final StmtContext context) { @@ -56,7 +56,7 @@ public class WhenStatementImpl extends AbstractDeclaredStatement> stmt) { super.onFullDefinitionDeclared(stmt); SUBSTATEMENT_VALIDATOR.validate(stmt); -- 2.36.6