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<StatementDefinition, Cardinality> cardinalityMap;
private final StatementDefinition currentStatement;
private final SpecialCase specialCase;
}
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<StatementDefinition, Cardinality> cardinalityMap = ImmutableMap.builder();
private final StatementDefinition currentStatement;
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);
}
}
}
- private static class Cardinality {
+ private static final class Cardinality {
private final int min;
private final int max;
*/
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;
public class AnyxmlStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, AnyxmlStatement, ?> context) {
+ protected AnyxmlStatementImpl(final StmtContext<QName, AnyxmlStatement, ?> context) {
super(context);
}
}
@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<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> stmt) {
+ public void onStatementAdded(final Mutable<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
- public AnyxmlStatement createDeclared(StmtContext<QName, AnyxmlStatement, ?> ctx) {
+ public AnyxmlStatement createDeclared(final StmtContext<QName, AnyxmlStatement, ?> ctx) {
return new AnyxmlStatementImpl(ctx);
}
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, AnyxmlStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, AnyxmlStatement,
EffectiveStatement<QName, AnyxmlStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
private Optional<ContainerSchemaNode> getAnyXmlSchema(
- StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx,
- SchemaNodeIdentifier contentSchemaPath) {
+ final StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx,
+ final SchemaNodeIdentifier contentSchemaPath) {
final StatementContextBase<?, ?, ?> findNode = Utils.findNode(ctx.getRoot(), contentSchemaPath);
if (findNode != null) {
final EffectiveStatement<?, ?> anyXmlSchemaNode = findNode.buildEffective();
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<QName, ArgumentStatement, ?> context) {
+ final StmtContext<QName, ArgumentStatement, ?> context) {
super(context);
}
}
@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<QName, ArgumentStatement, ?> ctx) {
+ final StmtContext<QName, ArgumentStatement, ?> ctx) {
return new ArgumentStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, ArgumentStatement> createEffective(
- StmtContext<QName, ArgumentStatement, EffectiveStatement<QName, ArgumentStatement>> ctx) {
+ final StmtContext<QName, ArgumentStatement, EffectiveStatement<QName, ArgumentStatement>> ctx) {
return new ArgumentEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<QName, ArgumentStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, ArgumentStatement,
EffectiveStatement<QName, ArgumentStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
.builder(Rfc6020Mapping.AUGMENT)
- .add(Rfc6020Mapping.ANYXML, 0, MAX)
- .add(Rfc6020Mapping.CASE, 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.CASE)
+ .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 AugmentStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> context) {
public class BelongsToStatementImpl extends AbstractDeclaredStatement<String>
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<String, BelongsToStatement, ?> context) {
super(context);
public class BitStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, BitStatement, ?> context) {
+ protected BitStatementImpl(final StmtContext<QName, BitStatement, ?> context) {
super(context);
}
}
@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<QName, BitStatement, ?> ctx) {
+ public BitStatement createDeclared(final StmtContext<QName, BitStatement, ?> ctx) {
return new BitStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, BitStatement> createEffective(
- StmtContext<QName, BitStatement, EffectiveStatement<QName, BitStatement>> ctx) {
+ final StmtContext<QName, BitStatement, EffectiveStatement<QName, BitStatement>> ctx) {
return new BitEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<QName, BitStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, BitStatement,
EffectiveStatement<QName, BitStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class BitsSpecificationImpl extends AbstractDeclaredStatement<String> 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<String, TypeStatement.BitsSpecification, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, BitsSpecification,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, BitsSpecification,
EffectiveStatement<String, BitsSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class CaseStatementImpl extends AbstractDeclaredStatement<QName> 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(
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, CaseStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, CaseStatement,
EffectiveStatement<QName, CaseStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
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<QName, ChoiceStatement, ?> context) {
+ protected ChoiceStatementImpl(final StmtContext<QName, ChoiceStatement, ?> context) {
super(context);
}
}
@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<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> stmt) {
+ public void onStatementAdded(final Mutable<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
public ChoiceStatement createDeclared(
- StmtContext<QName, ChoiceStatement, ?> ctx) {
+ final StmtContext<QName, ChoiceStatement, ?> ctx) {
return new ChoiceStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, ChoiceStatement> createEffective(
- StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
+ final StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
return new ChoiceEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, ChoiceStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, ChoiceStatement,
EffectiveStatement<QName, ChoiceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class ContainerStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, ContainerStatement,?> context) {
+ protected ContainerStatementImpl(final StmtContext<QName, ContainerStatement,?> context) {
super(context);
}
}
@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<QName, ContainerStatement, EffectiveStatement<QName, ContainerStatement>> stmt) {
+ final Mutable<QName, ContainerStatement, EffectiveStatement<QName, ContainerStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
- public ContainerStatement createDeclared(StmtContext<QName, ContainerStatement,?> ctx) {
+ public ContainerStatement createDeclared(final StmtContext<QName, ContainerStatement,?> ctx) {
return new ContainerStatementImpl(ctx);
}
@Override
- public EffectiveStatement<QName,ContainerStatement> createEffective(StmtContext<QName,ContainerStatement,EffectiveStatement<QName,ContainerStatement>> ctx) {
+ public EffectiveStatement<QName,ContainerStatement> createEffective(final StmtContext<QName,ContainerStatement,EffectiveStatement<QName,ContainerStatement>> ctx) {
return new ContainerEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, ContainerStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, ContainerStatement,
EffectiveStatement<QName, ContainerStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class Decimal64SpecificationImpl extends AbstractDeclaredStatement<String> 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<String, Decimal64Specification, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, Decimal64Specification,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, Decimal64Specification,
EffectiveStatement<String, Decimal64Specification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind> 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<DeviateKind, DeviateStatement, ?> context) {
+ protected DeviateStatementImpl(final StmtContext<DeviateKind, DeviateStatement, ?> context) {
super(context);
}
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<DeviateKind, DeviateStatement, ?> ctx) {
+ @Override public DeviateStatement createDeclared(final StmtContext<DeviateKind, DeviateStatement, ?> ctx) {
return new DeviateStatementImpl(ctx);
}
@Override public EffectiveStatement<DeviateKind, DeviateStatement> createEffective(
- StmtContext<DeviateKind, DeviateStatement, EffectiveStatement<DeviateKind,
+ final StmtContext<DeviateKind, DeviateStatement, EffectiveStatement<DeviateKind,
DeviateStatement>> ctx) {
return new DeviateEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<DeviateKind, DeviateStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<DeviateKind, DeviateStatement,
EffectiveStatement<DeviateKind, DeviateStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class DeviationStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> 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<SchemaNodeIdentifier, DeviationStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class EnumSpecificationImpl extends AbstractDeclaredStatement<String> 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<String, TypeStatement.EnumSpecification, ?> context) {
+ protected EnumSpecificationImpl(final StmtContext<String, TypeStatement.EnumSpecification, ?> context) {
super(context);
}
}
@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<String, TypeStatement.EnumSpecification, ?> ctx) {
+ final StmtContext<String, TypeStatement.EnumSpecification, ?> ctx) {
return new EnumSpecificationImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement.EnumSpecification> createEffective(
- StmtContext<String, TypeStatement.EnumSpecification, EffectiveStatement<String, TypeStatement.EnumSpecification>> ctx) {
+ final StmtContext<String, TypeStatement.EnumSpecification, EffectiveStatement<String, TypeStatement.EnumSpecification>> ctx) {
return new EnumSpecificationEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, EnumSpecification,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, EnumSpecification,
EffectiveStatement<String, EnumSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class EnumStatementImpl extends AbstractDeclaredStatement<String> 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<String, EnumStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, EnumStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, EnumStatement,
EffectiveStatement<String, EnumStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class ExtensionStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, ExtensionStatement,?> context) {
*/
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;
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<QName, FeatureStatement, ?> context) {
+ final StmtContext<QName, FeatureStatement, ?> context) {
super(context);
}
}
@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<QName, FeatureStatement, ?> ctx) {
+ final StmtContext<QName, FeatureStatement, ?> ctx) {
return new FeatureStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, FeatureStatement> createEffective(
- StmtContext<QName, FeatureStatement, EffectiveStatement<QName, FeatureStatement>> ctx) {
+ final StmtContext<QName, FeatureStatement, EffectiveStatement<QName, FeatureStatement>> ctx) {
return new FeatureEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<QName, FeatureStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, FeatureStatement,
EffectiveStatement<QName, FeatureStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
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<QName, GroupingStatement, ?> context) {
+ final StmtContext<QName, GroupingStatement, ?> context) {
super(context);
}
}
@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<QName, GroupingStatement, ?> ctx) {
+ final StmtContext<QName, GroupingStatement, ?> ctx) {
return new GroupingStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, GroupingStatement> createEffective(
- StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
+ final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
return new GroupingEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, GroupingStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, GroupingStatement,
EffectiveStatement<QName, GroupingStatement>> stmt) {
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement<String> 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<String, TypeStatement.IdentityRefSpecification, ?> context) {
+ final StmtContext<String, TypeStatement.IdentityRefSpecification, ?> context) {
super(context);
}
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
@Override
public TypeStatement.IdentityRefSpecification createDeclared(
- StmtContext<String, TypeStatement.IdentityRefSpecification, ?> ctx) {
+ final StmtContext<String, TypeStatement.IdentityRefSpecification, ?> ctx) {
return new IdentityRefSpecificationImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement.IdentityRefSpecification> createEffective(
- StmtContext<String, TypeStatement.IdentityRefSpecification, EffectiveStatement<String, TypeStatement
+ final StmtContext<String, TypeStatement.IdentityRefSpecification, EffectiveStatement<String, TypeStatement
.IdentityRefSpecification>> ctx) {
return new IdentityRefSpecificationEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, IdentityRefSpecification,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, IdentityRefSpecification,
EffectiveStatement<String, IdentityRefSpecification>> stmt) {
final StmtContext<QName, ?, ?> baseStmt = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
BaseStatement.class);
}
@Override
- public void onStatementDefinitionDeclared(StmtContext.Mutable<String, IdentityRefSpecification,
+ public void onStatementDefinitionDeclared(final StmtContext.Mutable<String, IdentityRefSpecification,
EffectiveStatement<String, IdentityRefSpecification>> stmt) {
super.onStatementDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
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(
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<QName, IdentityStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement,
EffectiveStatement<QName, IdentityStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class ImportStatementDefinition extends
AbstractStatementSupport<String, ImportStatement, EffectiveStatement<String, ImportStatement>> {
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);
}
@Override
- public void onPreLinkageDeclared(Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
+ public void onPreLinkageDeclared(final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
final String moduleName = stmt.getStatementArgument();
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
});
}
- 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;
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;
public class IncludeStatementImpl extends AbstractDeclaredStatement<String> 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<String, IncludeStatement, ?> context) {
super(context);
*/
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;
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<QName, InputStatement, ?> context) {
+ protected InputStatementImpl(final StmtContext<QName, InputStatement, ?> context) {
super(context);
}
}
@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<QName, InputStatement, EffectiveStatement<QName, InputStatement>> stmt) {
+ public void onStatementAdded(final Mutable<QName, InputStatement, EffectiveStatement<QName, InputStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
public InputStatement createDeclared(
- StmtContext<QName, InputStatement, ?> ctx) {
+ final StmtContext<QName, InputStatement, ?> ctx) {
return new InputStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, InputStatement> createEffective(
- StmtContext<QName, InputStatement, EffectiveStatement<QName, InputStatement>> ctx) {
+ final StmtContext<QName, InputStatement, EffectiveStatement<QName, InputStatement>> ctx) {
return new InputEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, InputStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, InputStatement,
EffectiveStatement<QName, InputStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
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<String, TypeStatement.InstanceIdentifierSpecification, ?> ctx) {
+ final StmtContext<String, TypeStatement.InstanceIdentifierSpecification, ?> ctx) {
super(ctx);
}
}
@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<String, TypeStatement.InstanceIdentifierSpecification, ?> ctx) {
+ final StmtContext<String, TypeStatement.InstanceIdentifierSpecification, ?> ctx) {
return new InstanceIdentifierSpecificationImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement.InstanceIdentifierSpecification> createEffective(
- StmtContext<String, TypeStatement.InstanceIdentifierSpecification, EffectiveStatement<String, TypeStatement.InstanceIdentifierSpecification>> ctx) {
+ final StmtContext<String, TypeStatement.InstanceIdentifierSpecification, EffectiveStatement<String, TypeStatement.InstanceIdentifierSpecification>> ctx) {
return new InstanceIdentifierSpecificationEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, InstanceIdentifierSpecification,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, InstanceIdentifierSpecification,
EffectiveStatement<String, InstanceIdentifierSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
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<QName, LeafListStatement, ?> context) {
+ final StmtContext<QName, LeafListStatement, ?> context) {
super(context);
}
@Override
public void onStatementAdded(
- Mutable<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> stmt) {
+ final Mutable<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> 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<QName, LeafListStatement, ?> ctx) {
+ final StmtContext<QName, LeafListStatement, ?> ctx) {
return new LeafListStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, LeafListStatement> createEffective(
- StmtContext<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> ctx) {
+ final StmtContext<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> ctx) {
return new LeafListEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, LeafListStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, LeafListStatement,
EffectiveStatement<QName, LeafListStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class LeafStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, LeafStatement, ?> context) {
+ protected LeafStatementImpl(final StmtContext<QName, LeafStatement, ?> context) {
super(context);
}
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<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> stmt) {
+ public void onStatementAdded(final Mutable<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override public LeafStatement createDeclared(
- StmtContext<QName, LeafStatement, ?> ctx) {
+ final StmtContext<QName, LeafStatement, ?> ctx) {
return new LeafStatementImpl(ctx);
}
@Override public EffectiveStatement<QName, LeafStatement> createEffective(
- StmtContext<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
+ final StmtContext<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
return new LeafEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, LeafStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, LeafStatement,
EffectiveStatement<QName, LeafStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
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<String, TypeStatement.LeafrefSpecification, ?> context) {
+ final StmtContext<String, TypeStatement.LeafrefSpecification, ?> context) {
super(context);
}
}
@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<String, TypeStatement.LeafrefSpecification, ?> ctx) {
+ final StmtContext<String, TypeStatement.LeafrefSpecification, ?> ctx) {
return new LeafrefSpecificationImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement.LeafrefSpecification> createEffective(
- StmtContext<String, TypeStatement.LeafrefSpecification, EffectiveStatement<String, TypeStatement.LeafrefSpecification>> ctx) {
+ final StmtContext<String, TypeStatement.LeafrefSpecification, EffectiveStatement<String, TypeStatement.LeafrefSpecification>> ctx) {
return new LeafrefSpecificationEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, LeafrefSpecification,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, LeafrefSpecification,
EffectiveStatement<String, LeafrefSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class LengthStatementImpl extends AbstractDeclaredStatement<List<LengthConstraint>> 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<List<LengthConstraint>, LengthStatement, ?> context) {
+ protected LengthStatementImpl(final StmtContext<List<LengthConstraint>, LengthStatement, ?> context) {
super(context);
}
}
@Override
- public List<LengthConstraint> parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public List<LengthConstraint> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return TypeUtils.parseLengthListFromString(ctx, value);
}
@Override
- public LengthStatement createDeclared(StmtContext<List<LengthConstraint>, LengthStatement, ?> ctx) {
+ public LengthStatement createDeclared(final StmtContext<List<LengthConstraint>, LengthStatement, ?> ctx) {
return new LengthStatementImpl(ctx);
}
@Override
public EffectiveStatement<List<LengthConstraint>, LengthStatement> createEffective(
- StmtContext<List<LengthConstraint>, LengthStatement, EffectiveStatement<List<LengthConstraint>,
+ final StmtContext<List<LengthConstraint>, LengthStatement, EffectiveStatement<List<LengthConstraint>,
LengthStatement>> ctx) {
return new LengthEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<List<LengthConstraint>,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<List<LengthConstraint>,
LengthStatement, EffectiveStatement<List<LengthConstraint>, LengthStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
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<QName, ListStatement, ?> context) {
+ protected ListStatementImpl(final StmtContext<QName, ListStatement, ?> context) {
super(context);
}
}
@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<QName, ListStatement, EffectiveStatement<QName, ListStatement>> stmt) {
+ public void onStatementAdded(final Mutable<QName, ListStatement, EffectiveStatement<QName, ListStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
public ListStatement createDeclared(
- StmtContext<QName, ListStatement, ?> ctx) {
+ final StmtContext<QName, ListStatement, ?> ctx) {
return new ListStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, ListStatement> createEffective(
- StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
+ final StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
return new ListEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, ListStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, ListStatement,
EffectiveStatement<QName, ListStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
AbstractStatementSupport<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> {
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() {
}
@Override
- public void onPreLinkageDeclared(Mutable<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> stmt) {
+ public void onPreLinkageDeclared(final Mutable<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> stmt) {
final String moduleName = stmt.getStatementArgument();
final URI moduleNs = firstAttributeOf(stmt.declaredSubstatements(),
NavigableMap<SemVer, StmtContext<?, ?, ?>> modulesMap = stmt.getFromNamespace(
SemanticVersionModuleNamespace.class, moduleName);
if (modulesMap == null) {
- modulesMap = new TreeMap<SemVer, StmtContext<?, ?, ?>>();
+ modulesMap = new TreeMap<>();
}
SemVer moduleSemVer = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
if(moduleSemVer == null) {
public class MustStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> 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<RevisionAwareXPath, MustStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, MustStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<RevisionAwareXPath, MustStatement,
EffectiveStatement<RevisionAwareXPath, MustStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
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<QName, NotificationStatement, ?> context) {
+ final StmtContext<QName, NotificationStatement, ?> context) {
super(context);
}
}
@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<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> stmt) {
+ final Mutable<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
public NotificationStatement createDeclared(
- StmtContext<QName, NotificationStatement, ?> ctx) {
+ final StmtContext<QName, NotificationStatement, ?> ctx) {
return new NotificationStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, NotificationStatement> createEffective(
- StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
+ final StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
return new NotificationEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, NotificationStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, NotificationStatement,
EffectiveStatement<QName, NotificationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
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<String, TypeStatement.NumericalRestrictions, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, NumericalRestrictions,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, NumericalRestrictions,
EffectiveStatement<String, NumericalRestrictions>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class OutputStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, OutputStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, OutputStatement,
+ public void onFullDefinitionDeclared(final Mutable<QName, OutputStatement,
EffectiveStatement<QName, OutputStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class PatternStatementImpl extends AbstractDeclaredStatement<PatternConstraint> 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);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<PatternConstraint, PatternStatement,
+ public void onFullDefinitionDeclared(
final StmtContext.Mutable<PatternConstraint, PatternStatement,
EffectiveStatement<PatternConstraint, PatternStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
public class RangeStatementImpl extends AbstractDeclaredStatement<List<RangeConstraint>> 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
public static final BigDecimal YANG_MIN_NUM = BigDecimal.valueOf(-Double.MAX_VALUE);
public static final BigDecimal YANG_MAX_NUM = BigDecimal.valueOf(Double.MAX_VALUE);
- protected RangeStatementImpl(StmtContext<List<RangeConstraint>, RangeStatement, ?> context) {
+ protected RangeStatementImpl(final StmtContext<List<RangeConstraint>, RangeStatement, ?> context) {
super(context);
}
}
@Override
- public List<RangeConstraint> parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public List<RangeConstraint> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return TypeUtils.parseRangeListFromString(ctx, value);
}
@Override
- public RangeStatement createDeclared(StmtContext<List<RangeConstraint>, RangeStatement, ?> ctx) {
+ public RangeStatement createDeclared(final StmtContext<List<RangeConstraint>, RangeStatement, ?> ctx) {
return new RangeStatementImpl(ctx);
}
@Override
public EffectiveStatement<List<RangeConstraint>, RangeStatement> createEffective(
- StmtContext<List<RangeConstraint>, RangeStatement, EffectiveStatement<List<RangeConstraint>,
+ final StmtContext<List<RangeConstraint>, RangeStatement, EffectiveStatement<List<RangeConstraint>,
RangeStatement>> ctx) {
return new RangeEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<List<RangeConstraint>, RangeStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<List<RangeConstraint>, RangeStatement,
EffectiveStatement<List<RangeConstraint>, RangeStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
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;
public class RefineStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> 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<SchemaNodeIdentifier, RefineStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<SchemaNodeIdentifier, RefineStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, RefineStatement,
EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
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<Date, RevisionStatement, ?> context) {
super(context);
*/
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;
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<QName, RpcStatement, ?> context) {
+ protected RpcStatementImpl(final StmtContext<QName, RpcStatement, ?> context) {
super(context);
}
}
@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<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
+ public void onStatementAdded(final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
}
@Override
public RpcStatement createDeclared(
- StmtContext<QName, RpcStatement, ?> ctx) {
+ final StmtContext<QName, RpcStatement, ?> ctx) {
return new RpcStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, RpcStatement> createEffective(
- StmtContext<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> ctx) {
+ final StmtContext<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> ctx) {
return new RpcEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
+ public void onFullDefinitionDeclared(final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
*/
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;
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<String, TypeStatement.StringRestrictions, ?> context) {
+ protected StringRestrictionsImpl(final StmtContext<String, TypeStatement.StringRestrictions, ?> context) {
super(context);
}
}
@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<String, TypeStatement.StringRestrictions, ?> ctx) {
+ final StmtContext<String, TypeStatement.StringRestrictions, ?> ctx) {
return new StringRestrictionsImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement.StringRestrictions> createEffective(
- StmtContext<String, TypeStatement.StringRestrictions, EffectiveStatement<String, TypeStatement.StringRestrictions>> ctx) {
+ final StmtContext<String, TypeStatement.StringRestrictions, EffectiveStatement<String, TypeStatement.StringRestrictions>> ctx) {
return new StringRestrictionsEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, StringRestrictions,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, StringRestrictions,
EffectiveStatement<String, StringRestrictions>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
*/
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;
public class SubmoduleStatementImpl extends AbstractRootStatement<SubmoduleStatement> 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<Date> DEFAULT_REVISION = Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_REV);
*/
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;
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<String, TypeStatement, ?> context) {
public class TypedefStatementImpl extends AbstractDeclaredStatement<QName> 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<QName, TypedefStatement, ?> context) {
*/
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;
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<String, TypeStatement.UnionSpecification, ?> context) {
+ final StmtContext<String, TypeStatement.UnionSpecification, ?> context) {
super(context);
}
}
@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<String, TypeStatement.UnionSpecification, ?> ctx) {
+ final StmtContext<String, TypeStatement.UnionSpecification, ?> ctx) {
return new UnionSpecificationImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement.UnionSpecification> createEffective(
- StmtContext<String, TypeStatement.UnionSpecification, EffectiveStatement<String, TypeStatement.UnionSpecification>> ctx) {
+ final StmtContext<String, TypeStatement.UnionSpecification, EffectiveStatement<String, TypeStatement.UnionSpecification>> ctx) {
return new UnionSpecificationEffectiveStatementImpl(ctx);
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> stmt) {
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
*/
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;
public class UsesStatementImpl extends AbstractDeclaredStatement<QName> 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);
public class WhenStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> 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<RevisionAwareXPath, WhenStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, WhenStatement,
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<RevisionAwareXPath, WhenStatement,
EffectiveStatement<RevisionAwareXPath, WhenStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
Code Review / yangtools.git / commitdiff