--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.yang.parser.spi;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.Maps;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InvalidSubstatementException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.MissingSubstatementException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+
+public final class SubstatementValidator {
+ private final Map<StatementDefinition, Cardinality> cardinalityMap;
+ private final StatementDefinition currentStatement;
+ private final SpecialCase specialCase;
+ public final static int MAX = Integer.MAX_VALUE;
+
+ private SubstatementValidator(Builder builder, SpecialCase specialCase) {
+ this.cardinalityMap = builder.cardinalityMap.build();
+ this.currentStatement = builder.currentStatement;
+ this.specialCase = specialCase;
+ }
+
+ public static Builder builder(StatementDefinition currentStatement) {
+ return new Builder(currentStatement);
+ }
+
+ public static class Builder {
+ private final ImmutableMap.Builder<StatementDefinition, Cardinality> cardinalityMap = ImmutableMap.builder();
+ private final StatementDefinition currentStatement;
+
+ private Builder(StatementDefinition currentStatement) {
+ this.currentStatement = currentStatement;
+ }
+
+ public Builder add(StatementDefinition d, int min, int max) {
+ this.cardinalityMap.put(d, new Cardinality(min, max));
+ return this;
+ }
+
+ public SubstatementValidator build() {
+ return new SubstatementValidator(this, SpecialCase.NULL);
+ }
+
+ public SubstatementValidator build(SpecialCase specialCase) {
+ return new SubstatementValidator(this, specialCase);
+ }
+ }
+
+ public void validate(StmtContext ctx) throws InvalidSubstatementException, MissingSubstatementException{
+ final Map<StatementDefinition, Integer> stmtDefMap = new HashMap<>();
+ final Map<StatementDefinition, Integer> validatedMap = new HashMap<>();
+ final Collection<StatementContextBase<?, ?, ?>> substatementsInit = new ArrayList<>();
+ substatementsInit.addAll(ctx.declaredSubstatements());
+ substatementsInit.addAll(ctx.effectiveSubstatements());
+
+ for (StatementContextBase<?, ?, ?> stmtCtx : substatementsInit) {
+ final StatementDefinition definition = stmtCtx.getPublicDefinition();
+ if (!stmtDefMap.containsKey(definition)) {
+ stmtDefMap.put(definition, 1);
+ } else {
+ stmtDefMap.put(definition, stmtDefMap.get(definition) + 1);
+ }
+ }
+
+ if (stmtDefMap.isEmpty() && specialCase == SpecialCase.NOTNULL) {
+ throw new InvalidSubstatementException(String.format("%s must contain atleast 1 element. Error in module " +
+ "%s (%s)", currentStatement, ctx.getRoot().getStatementArgument(), ctx.getFromNamespace
+ (ModuleCtxToModuleQName.class, ctx.getRoot())), ctx.getStatementSourceReference());
+ }
+
+ for (Map.Entry entry : stmtDefMap.entrySet()) {
+ final StatementDefinition key = (StatementDefinition) entry.getKey();
+ if (!cardinalityMap.containsKey(key)) {
+ if (ctx.getFromNamespace(ExtensionNamespace.class, key.getArgumentName()) != null) {
+ continue;
+ }
+ throw new InvalidSubstatementException(String.format("%s is not valid for %s. Error in module %s (%s)",
+ key, currentStatement, ctx.getRoot().getStatementArgument(),
+ ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())),
+ ctx.getStatementSourceReference());
+ }
+ if (cardinalityMap.get(key).getMin() > (Integer)entry.getValue()) {
+ throw new InvalidSubstatementException(String.format("Minimal count of %s for %s is %s, detected %s. " +
+ "Error in module %s (%s)", key, currentStatement, cardinalityMap.get(key).getMin(),
+ entry.getValue(), ctx.getRoot().getStatementArgument(),
+ ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())),
+ ctx.getStatementSourceReference());
+ }
+ if (cardinalityMap.get(key).getMax() < (Integer)entry.getValue()) {
+ throw new InvalidSubstatementException(String.format("Maximal count of %s for %s is %s, detected %s. " +
+ "Error in module %s (%s)", key, currentStatement, cardinalityMap.get(key).getMax(),
+ entry.getValue(), ctx.getRoot().getStatementArgument(),
+ ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())),
+ ctx.getStatementSourceReference());
+ }
+ validatedMap.put(key, 1);
+ }
+
+ final MapDifference<StatementDefinition, Object> diff = Maps.difference(validatedMap, cardinalityMap);
+
+ for (Map.Entry entry : diff.entriesOnlyOnRight().entrySet()) {
+ final int min = ((Cardinality)entry.getValue()).getMin();
+ if (min > 0) {
+ throw new MissingSubstatementException(String.format("%s is missing %s. Minimal count is %s. Error in" +
+ " module %s (%s)", currentStatement, entry.getKey(), min, ctx.getRoot().getStatementArgument(),
+ ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot())),
+ ctx.getStatementSourceReference());
+ }
+ }
+ }
+
+ private static class Cardinality {
+ private final int min;
+ private final int max;
+
+ private Cardinality(int min, int max) throws YangParseException {
+ if (min > max) {
+ throw new IllegalArgumentException("Min can not be greater than max!");
+ }
+ if (min < 0) {
+ throw new IllegalArgumentException("Min can not be les than 0!");
+ }
+ this.min = min;
+ this.max = max;
+ }
+
+ private int getMax() {
+ return max;
+ }
+
+ private int getMin() {
+ return min;
+ }
+ }
+
+ public enum SpecialCase {
+ NOTNULL,
+ NULL
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.spi.meta;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
+
+/**
+ *
+ * Thrown when there was Invalid element in yang file
+ *
+ */
+public class InvalidSubstatementException extends SourceException {
+ public InvalidSubstatementException(@Nonnull String message, @Nonnull StatementSourceReference source, Throwable cause) {
+ super(message, source, cause);
+ }
+
+ public InvalidSubstatementException(@Nonnull String message, @Nonnull StatementSourceReference source) {
+ super(message, source);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.spi.meta;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
+
+/**
+ *
+ * Thrown when there was Missing element in yang file
+ *
+ */
+public class MissingSubstatementException extends SourceException {
+ public MissingSubstatementException(@Nonnull String message, @Nonnull StatementSourceReference source) {
+ super(message, source);
+ }
+
+ public MissingSubstatementException(@Nonnull String message, @Nonnull StatementSourceReference source, Throwable cause) {
+ super(message, source, cause);
+ }
+}
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AnyXmlEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
-import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AnyXmlEffectiveStatementImpl;
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)
+ .build();
protected AnyxmlStatementImpl(StmtContext<QName, AnyxmlStatement,?> context) {
super(context);
return new AnyXmlEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, AnyxmlStatement,
+ EffectiveStatement<QName, AnyxmlStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ArgumentEffectiveStatementImpl;
-
-import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ArgumentEffectiveStatementImpl;
public class ArgumentStatementImpl extends AbstractDeclaredStatement<QName>
implements ArgumentStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .ARGUMENT)
+ .add(Rfc6020Mapping.YIN_ELEMENT, 0, 1)
+ .build();
protected ArgumentStatementImpl(
StmtContext<QName, ArgumentStatement, ?> context) {
return new ArgumentEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, ArgumentStatement,
+ EffectiveStatement<QName, ArgumentStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
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;
import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
private static final Logger LOG = LoggerFactory.getLogger(AugmentStatementImpl.class);
private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
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)
+ .build();
protected AugmentStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> context) {
super(context);
public void onFullDefinitionDeclared(
final StmtContext.Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode)
throws SourceException {
+ SUBSTATEMENT_VALIDATOR.validate(augmentNode);
if (StmtContextUtils.isInExtensionBody(augmentNode)) {
return;
import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedIdentitiesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BaseEffectiveStatementImpl;
public class BaseStatementImpl extends AbstractDeclaredStatement<QName> implements BaseStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .BASE)
+ .build();
protected BaseStatementImpl(final StmtContext<QName, BaseStatement, ?> context) {
super(context);
});
}
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, BaseStatement,
+ EffectiveStatement<QName, BaseStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
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();
protected BelongsToStatementImpl(
final StmtContext<String, BelongsToStatement, ?> context) {
String moduleName = belongsToCtx.getStatementArgument();
return new ModuleIdentifierImpl(moduleName, Optional.<URI> absent(), Optional.of(SimpleDateFormatUtil.DEFAULT_BELONGS_TO_DATE));
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, BelongsToStatement,
+ EffectiveStatement<String, BelongsToStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitEffectiveStatementImpl;
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)
+ .build();
protected BitStatementImpl(StmtContext<QName, BitStatement, ?> context) {
super(context);
return new BitEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, BitStatement,
+ EffectiveStatement<QName, BitStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
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;
import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsSpecificationEffectiveStatementImpl;
public class BitsSpecificationImpl extends AbstractDeclaredStatement<String> implements TypeStatement.BitsSpecification {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.BIT, 1, MAX)
+ .build();
protected BitsSpecificationImpl(final StmtContext<String, TypeStatement.BitsSpecification, ?> context) {
super(context);
final StmtContext<String, TypeStatement.BitsSpecification, EffectiveStatement<String, TypeStatement.BitsSpecification>> ctx) {
return new BitsSpecificationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, BitsSpecification,
+ EffectiveStatement<String, BitsSpecification>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
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;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.CaseEffectiveStatementImpl;
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)
+ .build();
protected CaseStatementImpl(
final StmtContext<QName, CaseStatement, ?> context) {
final StmtContext<QName, CaseStatement, EffectiveStatement<QName, CaseStatement>> ctx) {
return new CaseEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, CaseStatement,
+ EffectiveStatement<QName, CaseStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ChoiceEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.Collection;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ChoiceEffectiveStatementImpl;
public class ChoiceStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected ChoiceStatementImpl(StmtContext<QName, ChoiceStatement, ?> context) {
super(context);
StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
return new ChoiceEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, ChoiceStatement,
+ EffectiveStatement<QName, ChoiceStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ConfigEffectiveStatementImpl;
-
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ConfigEffectiveStatementImpl;
public class ConfigStatementImpl extends AbstractDeclaredStatement<Boolean> implements ConfigStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .CONFIG)
+ .build();
protected ConfigStatementImpl(
StmtContext<Boolean, ConfigStatement, ?> context) {
@Override public EffectiveStatement<Boolean, ConfigStatement> createEffective(StmtContext<Boolean, ConfigStatement, EffectiveStatement<Boolean, ConfigStatement>> ctx) {
return new ConfigEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Boolean, ConfigStatement,
+ EffectiveStatement<Boolean, ConfigStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContactEffectiveStatementImpl;
-
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContactEffectiveStatementImpl;
public class ContactStatementImpl extends AbstractDeclaredStatement<String> implements ContactStatement{
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .CONTACT)
+ .build();
protected ContactStatementImpl(StmtContext<String, ContactStatement,?> context) {
super(context);
public EffectiveStatement<String, ContactStatement> createEffective(StmtContext<String, ContactStatement, EffectiveStatement<String, ContactStatement>> ctx) {
return new ContactEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, ContactStatement,
+ EffectiveStatement<String, ContactStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
+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.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
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)
+ .build();
protected ContainerStatementImpl(StmtContext<QName, ContainerStatement,?> context) {
super(context);
return new ContainerEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, ContainerStatement,
+ EffectiveStatement<QName, ContainerStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Decimal64SpecificationEffectiveStatementImpl;
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)
+ .build();
protected Decimal64SpecificationImpl(final StmtContext<String, Decimal64Specification, ?> context) {
super(context);
final StmtContext<String, Decimal64Specification, EffectiveStatement<String, Decimal64Specification>> ctx) {
return new Decimal64SpecificationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, Decimal64Specification,
+ EffectiveStatement<String, Decimal64Specification>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DefaultEffectiveStatementImpl;
-
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DefaultEffectiveStatementImpl;
public class DefaultStatementImpl extends AbstractDeclaredStatement<String> implements
DefaultStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .DEFAULT)
+ .build();
protected DefaultStatementImpl(
StmtContext<String, DefaultStatement, ?> context) {
StmtContext<String, DefaultStatement, EffectiveStatement<String, DefaultStatement>> ctx) {
return new DefaultEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, DefaultStatement,
+ EffectiveStatement<String, DefaultStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl;
-
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl;
public class DescriptionStatementImpl extends AbstractDeclaredStatement<String> implements DescriptionStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .DESCRIPTION)
+ .build();
protected DescriptionStatementImpl(
StmtContext<String, DescriptionStatement, ?> context) {
public EffectiveStatement<String, DescriptionStatement> createEffective(StmtContext<String, DescriptionStatement, EffectiveStatement<String, DescriptionStatement>> ctx) {
return new DescriptionEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, DescriptionStatement,
+ EffectiveStatement<String, DescriptionStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviateEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-
-import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviateEffectiveStatementImpl;
public class DeviateStatementImpl extends AbstractDeclaredStatement<Deviation.Deviate> 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)
+ .build();
protected DeviateStatementImpl(
StmtContext<Deviation.Deviate, DeviateStatement, ?> context) {
return new DeviateEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Deviation.Deviate, DeviateStatement,
+ EffectiveStatement<Deviation.Deviate, DeviateStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
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;
import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviationEffectiveStatementImpl;
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)
+ .build();
protected DeviationStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> context) {
super(context);
final StmtContext<SchemaNodeIdentifier, DeviationStatement, EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) {
return new DeviationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
+ EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.util.Collection;
+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;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumSpecificationEffectiveStatementImpl;
public class EnumSpecificationImpl extends AbstractDeclaredStatement<String> implements TypeStatement.EnumSpecification {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.ENUM, 1, MAX)
+ .build();
protected EnumSpecificationImpl(StmtContext<String, TypeStatement.EnumSpecification, ?> context) {
super(context);
StmtContext<String, TypeStatement.EnumSpecification, EffectiveStatement<String, TypeStatement.EnumSpecification>> ctx) {
return new EnumSpecificationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, EnumSpecification,
+ EffectiveStatement<String, EnumSpecification>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumEffectiveStatementImpl;
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)
+ .build();
protected EnumStatementImpl(final StmtContext<String, EnumStatement, ?> context) {
super(context);
final StmtContext<String, EnumStatement, EffectiveStatement<String, EnumStatement>> ctx) {
return new EnumEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, EnumStatement,
+ EffectiveStatement<String, EnumStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorAppTagEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorAppTagEffectiveStatementImpl;
public class ErrorAppTagStatementImpl extends AbstractDeclaredStatement<String>
implements ErrorAppTagStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .ERROR_APP_TAG)
+ .build();
protected ErrorAppTagStatementImpl(
StmtContext<String, ErrorAppTagStatement, ?> context) {
return new ErrorAppTagEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, ErrorAppTagStatement,
+ EffectiveStatement<String, ErrorAppTagStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorMessageEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorMessageEffectiveStatementImpl;
public class ErrorMessageStatementImpl extends
AbstractDeclaredStatement<String> implements ErrorMessageStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .ERROR_MESSAGE)
+ .build();
protected ErrorMessageStatementImpl(
StmtContext<String, ErrorMessageStatement, ?> context) {
return new ErrorMessageEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, ErrorMessageStatement,
+ EffectiveStatement<String, ErrorMessageStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtensionEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtensionEffectiveStatementImpl;
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)
+ .build();
protected ExtensionStatementImpl(StmtContext<QName, ExtensionStatement,?> context) {
super(context);
public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) throws SourceException {
stmt.addContext(ExtensionNamespace.class, stmt.getStatementArgument(), stmt);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, ExtensionStatement,
+ EffectiveStatement<QName, ExtensionStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FeatureEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FeatureEffectiveStatementImpl;
public class FeatureStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected FeatureStatementImpl(
StmtContext<QName, FeatureStatement, ?> context) {
return new FeatureEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, FeatureStatement,
+ EffectiveStatement<QName, FeatureStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import com.google.common.collect.Range;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FractionDigitsEffectiveStatementImpl;
-import com.google.common.collect.Range;
-
public class FractionDigitsStatementImpl extends AbstractDeclaredStatement<Integer> implements FractionDigitsStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .FRACTION_DIGITS)
+ .build();
private static final Range<Integer> FRAC_DIGITS_ALLOWED = Range.closed(1, 18);
return new FractionDigitsEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Integer, FractionDigitsStatement,
+ EffectiveStatement<Integer, FractionDigitsStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.util.Collection;
+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;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public class GroupingStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected GroupingStatementImpl(
StmtContext<QName, GroupingStatement, ?> context) {
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> stmt) throws SourceException {
+ public void onFullDefinitionDeclared(Mutable<QName, GroupingStatement,
+ EffectiveStatement<QName, GroupingStatement>> stmt) throws SourceException {
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+
if (stmt != null && stmt.getParentContext() != null) {
stmt.getParentContext().addContext(GroupingNamespace.class, stmt.getStatementArgument(), stmt);
}
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.IdentityRefSpecificationEffectiveStatementImpl;
-import javax.annotation.Nonnull;
-
public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement<String> implements TypeStatement.IdentityRefSpecification {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.BASE, 1, 1)
+ .build();
protected IdentityRefSpecificationImpl(
StmtContext<String, TypeStatement.IdentityRefSpecification, ?> context) {
"in " + "given scope " + "(module, imported submodules), source: '%s'", baseIdentity
.getLocalName(), stmt.getStatementSourceReference());
}
+
+ @Override
+ public void onStatementDefinitionDeclared(StmtContext.Mutable<String, IdentityRefSpecification,
+ EffectiveStatement<String, IdentityRefSpecification>> stmt) throws SourceException {
+ super.onStatementDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public class IdentityStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected IdentityStatementImpl(
final StmtContext<QName, IdentityStatement, ?> context) {
public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> stmt) throws SourceException {
stmt.addToNs(IdentityNamespace.class, stmt.getStatementArgument(), stmt);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, IdentityStatement,
+ EffectiveStatement<QName, IdentityStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IfFeatureEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IfFeatureEffectiveStatementImpl;
public class IfFeatureStatementImpl extends AbstractDeclaredStatement<QName>
implements IfFeatureStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .IF_FEATURE)
+ .build();
protected IfFeatureStatementImpl(
StmtContext<QName, IfFeatureStatement, ?> context) {
return new IfFeatureEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, IfFeatureStatement,
+ EffectiveStatement<QName, IfFeatureStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+
import com.google.common.base.Optional;
import java.net.URI;
import java.util.Collection;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToModuleIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ImportEffectiveStatementImpl;
public class ImportStatementDefinition
extends AbstractStatementSupport<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)
+ .build();
public ImportStatementDefinition() {
super(Rfc6020Mapping.IMPORT);
return new ImportEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<String, ImportStatement,
+ EffectiveStatement<String, ImportStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
+
@Override
public void onLinkageDeclared(
final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
}
}
});
+
+
}
private static ModuleIdentifier getImportedModuleIdentifier(final Mutable<String, ImportStatement, ?> stmt) {
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
-import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToIdentifier;
-
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IncludeEffectiveStatementImpl;
+import com.google.common.base.Optional;
import java.net.URI;
import java.util.Collection;
import java.util.Date;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import com.google.common.base.Optional;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IncludeEffectiveStatementImpl;
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();
protected IncludeStatementImpl(StmtContext<String, IncludeStatement, ?> context) {
super(context);
return new ModuleIdentifierImpl(subModuleName, Optional.<URI> absent(), Optional.<Date> of(revisionDate));
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<String, IncludeStatement,
+ EffectiveStatement<String, IncludeStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
public class InputStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected InputStatementImpl(StmtContext<QName, InputStatement, ?> context) {
super(context);
return new InputEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, InputStatement,
+ EffectiveStatement<QName, InputStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
-
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.InstanceIdentifierSpecificationEffectiveStatementImpl;
public class InstanceIdentifierSpecificationImpl extends
AbstractDeclaredStatement<String> implements
TypeStatement.InstanceIdentifierSpecification {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.REQUIRE_INSTANCE, 0, 1)
+ .build();
protected InstanceIdentifierSpecificationImpl(
StmtContext<String, TypeStatement.InstanceIdentifierSpecification, ?> ctx) {
StmtContext<String, TypeStatement.InstanceIdentifierSpecification, EffectiveStatement<String, TypeStatement.InstanceIdentifierSpecification>> ctx) {
return new InstanceIdentifierSpecificationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, InstanceIdentifierSpecification,
+ EffectiveStatement<String, InstanceIdentifierSpecification>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.KeyEffectiveStatementImpl;
public class KeyStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier>> implements
KeyStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .KEY)
+ .build();
protected KeyStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> context) {
super(context);
final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> ctx) {
return new KeyEffectiveStatementImpl(ctx);
}
- }
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Collection<SchemaNodeIdentifier>, KeyStatement,
+ EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
+ }
}
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafListEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.Collection;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafListEffectiveStatementImpl;
public class LeafListStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected LeafListStatementImpl(
StmtContext<QName, LeafListStatement, ?> context) {
StmtContext<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> ctx) {
return new LeafListEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, LeafListStatement,
+ EffectiveStatement<QName, LeafListStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.Collection;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
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)
+ .build();
protected LeafStatementImpl(StmtContext<QName, LeafStatement, ?> context) {
super(context);
StmtContext<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
return new LeafEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, LeafStatement,
+ EffectiveStatement<QName, LeafStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nullable @Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LeafrefSpecificationEffectiveStatementImpl;
public class LeafrefSpecificationImpl extends AbstractDeclaredStatement<String>
implements TypeStatement.LeafrefSpecification {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.PATH, 1, 1)
+ .add(Rfc6020Mapping.REQUIRE_INSTANCE, 0, 1)
+ .build();
protected LeafrefSpecificationImpl(
StmtContext<String, TypeStatement.LeafrefSpecification, ?> context) {
StmtContext<String, TypeStatement.LeafrefSpecification, EffectiveStatement<String, TypeStatement.LeafrefSpecification>> ctx) {
return new LeafrefSpecificationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, LeafrefSpecification,
+ EffectiveStatement<String, LeafrefSpecification>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LengthEffectiveStatementImpl;
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)
+ .build();
protected LengthStatementImpl(StmtContext<List<LengthConstraint>, LengthStatement, ?> context) {
super(context);
StmtContext<List<LengthConstraint>, LengthStatement, EffectiveStatement<List<LengthConstraint>, LengthStatement>> ctx) {
return new LengthEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<List<LengthConstraint>,
+ LengthStatement, EffectiveStatement<List<LengthConstraint>, LengthStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ListEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.Collection;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ListEffectiveStatementImpl;
public class ListStatementImpl extends AbstractDeclaredStatement<QName>
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)
+ .build();
protected ListStatementImpl(StmtContext<QName, ListStatement, ?> context) {
super(context);
StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
return new ListEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, ListStatement,
+ EffectiveStatement<QName, ListStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MandatoryEffectiveStatementImpl;
public class MandatoryStatementImpl extends AbstractDeclaredStatement<Boolean> implements MandatoryStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .MANDATORY)
+ .build();
protected MandatoryStatementImpl(final StmtContext<Boolean, MandatoryStatement, ?> context) {
super(context);
}
return ret;
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Boolean, MandatoryStatement,
+ EffectiveStatement<Boolean, MandatoryStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MaxElementsEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MaxElementsEffectiveStatementImpl;
public class MaxElementsStatementImpl extends AbstractDeclaredStatement<String>
implements MaxElementsStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .MAX_ELEMENTS)
+ .build();
protected MaxElementsStatementImpl(
StmtContext<String, MaxElementsStatement, ?> context) {
return new MaxElementsEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, MaxElementsStatement,
+ EffectiveStatement<String, MaxElementsStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MinElementsEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MinElementsEffectiveStatementImpl;
public class MinElementsStatementImpl extends
AbstractDeclaredStatement<Integer> implements MinElementsStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .MIN_ELEMENTS)
+ .build();
protected MinElementsStatementImpl(
StmtContext<Integer, MinElementsStatement, ?> context) {
StmtContext<Integer, MinElementsStatement, EffectiveStatement<Integer, MinElementsStatement>> ctx) {
return new MinElementsEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Integer, MinElementsStatement,
+ EffectiveStatement<Integer, MinElementsStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
import org.opendaylight.yangtools.yang.parser.spi.NamespaceToModule;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
public class ModuleStatementSupport extends
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)
+ .build();
public ModuleStatementSupport() {
super(Rfc6020Mapping.MODULE);
stmt.addToNs(ImpPrefixToModuleIdentifier.class, modulePrefix, moduleIdentifier);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<String, ModuleStatement,
+ EffectiveStatement<String, ModuleStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MustEffectiveStatementImpl;
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)
+ .build();
protected MustStatementImpl(final StmtContext<RevisionAwareXPath, MustStatement, ?> context) {
super(context);
final StmtContext<RevisionAwareXPath, MustStatement, EffectiveStatement<RevisionAwareXPath, MustStatement>> ctx) {
return new MustEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, MustStatement,
+ EffectiveStatement<RevisionAwareXPath, MustStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NamespaceEffectiveStatementImpl;
-
import java.net.URI;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NamespaceEffectiveStatementImpl;
public class NamespaceStatementImpl extends AbstractDeclaredStatement<URI> implements NamespaceStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .NAMESPACE)
+ .build();
public static class Definition extends AbstractStatementSupport<URI,NamespaceStatement,EffectiveStatement<URI,NamespaceStatement>> {
return new NamespaceEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<URI, NamespaceStatement,
+ EffectiveStatement<URI, NamespaceStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
NamespaceStatementImpl(StmtContext<URI, NamespaceStatement,?> context) {
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NotificationEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
-import javax.annotation.Nullable;
import java.util.Collection;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NotificationEffectiveStatementImpl;
public class NotificationStatementImpl extends AbstractDeclaredStatement<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)
+ .build();
protected NotificationStatementImpl(
StmtContext<QName, NotificationStatement, ?> context) {
return new NotificationEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, NotificationStatement,
+ EffectiveStatement<QName, NotificationStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.NumericalRestrictionsEffectiveStatementImpl;
public class NumericalRestrictionsImpl extends AbstractDeclaredStatement<String> implements
TypeStatement.NumericalRestrictions {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.RANGE, 1, 1)
+ .build();
protected NumericalRestrictionsImpl(final StmtContext<String, TypeStatement.NumericalRestrictions, ?> context) {
super(context);
final StmtContext<String, TypeStatement.NumericalRestrictions, EffectiveStatement<String, TypeStatement.NumericalRestrictions>> ctx) {
return new NumericalRestrictionsEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, NumericalRestrictions,
+ EffectiveStatement<String, NumericalRestrictions>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrderedByEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrderedByEffectiveStatementImpl;
public class OrderedByStatementImpl extends AbstractDeclaredStatement<String>
implements OrderedByStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .ORDERED_BY)
+ .build();
protected OrderedByStatementImpl(
StmtContext<String, OrderedByStatement, ?> context) {
return new OrderedByEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, OrderedByStatement,
+ EffectiveStatement<String, OrderedByStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrganizationEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrganizationEffectiveStatementImpl;
public class OrganizationStatementImpl extends
AbstractDeclaredStatement<String> implements OrganizationStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .ORGANIZATION)
+ .build();
protected OrganizationStatementImpl(
StmtContext<String, OrganizationStatement, ?> context) {
return new OrganizationEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, OrganizationStatement,
+ EffectiveStatement<String, OrganizationStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
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;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl;
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)
+ .build();
protected OutputStatementImpl(final StmtContext<QName, OutputStatement, ?> context) {
super(context);
final StmtContext<QName, OutputStatement, EffectiveStatement<QName, OutputStatement>> ctx) {
return new OutputEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, OutputStatement,
+ EffectiveStatement<QName, OutputStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PathEffectiveStatementImpl;
public class PathStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements PathStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .PATH)
+ .build();
protected PathStatementImpl(final StmtContext<RevisionAwareXPath, PathStatement, ?> context) {
super(context);
final StmtContext<RevisionAwareXPath, PathStatement, EffectiveStatement<RevisionAwareXPath, PathStatement>> ctx) {
return new PathEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, PathStatement,
+ EffectiveStatement<RevisionAwareXPath, PathStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternConstraintEffectiveImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternEffectiveStatementImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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)
+ .build();
private static final Logger LOG = LoggerFactory.getLogger(PatternStatementImpl.class);
protected PatternStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> context) {
final StmtContext<PatternConstraint, PatternStatement, EffectiveStatement<PatternConstraint, PatternStatement>> ctx) {
return new PatternEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<PatternConstraint, PatternStatement,
+ EffectiveStatement<PatternConstraint, PatternStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PositionEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PositionEffectiveStatementImpl;
public class PositionStatementImpl extends AbstractDeclaredStatement<Long>
implements PositionStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .POSITION)
+ .build();
protected PositionStatementImpl(
StmtContext<Long, PositionStatement, ?> context) {
return new PositionEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Long, PositionStatement,
+ EffectiveStatement<Long, PositionStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PrefixEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PrefixEffectiveStatementImpl;
public class PrefixStatementImpl extends AbstractDeclaredStatement<String> implements PrefixStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .PREFIX)
+ .build();
public static class Definition extends AbstractStatementSupport<String,PrefixStatement,EffectiveStatement<String,PrefixStatement>> {
public EffectiveStatement<String,PrefixStatement> createEffective(StmtContext<String, PrefixStatement,EffectiveStatement<String,PrefixStatement>> ctx) {
return new PrefixEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, PrefixStatement,
+ EffectiveStatement<String, PrefixStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
PrefixStatementImpl(StmtContext<String, PrefixStatement,?> context) {
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PresenceEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PresenceEffectiveStatementImpl;
public class PresenceStatementImpl extends AbstractDeclaredStatement<String>
implements PresenceStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .PRESENCE)
+ .build();
protected PresenceStatementImpl(
StmtContext<String, PresenceStatement, ?> context) {
return new PresenceEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, PresenceStatement,
+ EffectiveStatement<String, PresenceStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import java.math.BigDecimal;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.RangeEffectiveStatementImpl;
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)
+ .build();
// these objects are to compare whether range has MAX or MIN value
// none of these values should appear as Yang number according to spec so they are safe to use
StmtContext<List<RangeConstraint>, RangeStatement, EffectiveStatement<List<RangeConstraint>, RangeStatement>> ctx) {
return new RangeEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<List<RangeConstraint>, RangeStatement,
+ EffectiveStatement<List<RangeConstraint>, RangeStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ReferenceEffectiveStatementImpl;
public class ReferenceStatementImpl extends AbstractDeclaredStatement<String> implements ReferenceStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .REFERENCE)
+ .build();
protected ReferenceStatementImpl(final StmtContext<String, ReferenceStatement, ?> context) {
super(context);
final StmtContext<String, ReferenceStatement, EffectiveStatement<String, ReferenceStatement>> ctx) {
return new ReferenceEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, ReferenceStatement,
+ EffectiveStatement<String, ReferenceStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RefineEffectiveStatementImpl;
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, 1)
+ .add(Rfc6020Mapping.MIN_ELEMENTS, 0, 1)
+ .add(Rfc6020Mapping.MAX_ELEMENTS, 0, 1)
+ .build(SubstatementValidator.SpecialCase.NOTNULL);
protected RefineStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> context) {
super(context);
final StmtContext<SchemaNodeIdentifier, RefineStatement, EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> ctx) {
return new RefineEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<SchemaNodeIdentifier, RefineStatement,
+ EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl;
public class RequireInstanceStatementImpl extends
AbstractDeclaredStatement<Boolean> implements RequireInstanceStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .REQUIRE_INSTANCE)
+ .build();
protected RequireInstanceStatementImpl(
StmtContext<Boolean, RequireInstanceStatement, ?> context) {
return new RequireInstanceEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Boolean, RequireInstanceStatement,
+ EffectiveStatement<Boolean, RequireInstanceStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-
import java.text.ParseException;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import java.util.Date;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionDateEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionDateEffectiveStatementImpl;
public class RevisionDateStatementImpl extends
AbstractDeclaredStatement<Date> implements RevisionDateStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .REVISION_DATE)
+ .build();
protected RevisionDateStatementImpl(
StmtContext<Date, RevisionDateStatement, ?> context) {
return new RevisionDateEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Date, RevisionDateStatement,
+ EffectiveStatement<Date, RevisionDateStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import java.text.ParseException;
import java.util.Date;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionEffectiveStatementImpl;
public class RevisionStatementImpl extends AbstractDeclaredStatement<Date>
implements RevisionStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .REVISION)
+ .add(Rfc6020Mapping.DESCRIPTION, 0, 1)
+ .add(Rfc6020Mapping.REFERENCE, 0, 1)
+ .build();
protected RevisionStatementImpl(
StmtContext<Date, RevisionStatement, ?> context) {
StmtContext<Date, RevisionStatement, EffectiveStatement<Date, RevisionStatement>> ctx) {
return new RevisionEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Date, RevisionStatement,
+ EffectiveStatement<Date, RevisionStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RpcEffectiveStatementImpl;
+import static org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator.MAX;
-import javax.annotation.Nullable;
import java.util.Collection;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RpcEffectiveStatementImpl;
public class RpcStatementImpl extends AbstractDeclaredStatement<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)
+ .build();
protected RpcStatementImpl(StmtContext<QName, RpcStatement, ?> context) {
super(context);
return new RpcEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(Mutable<QName, RpcStatement,
+ EffectiveStatement<QName, RpcStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.model.api.Status;
-
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.StatusEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.StatusEffectiveStatementImpl;
public class StatusStatementImpl extends AbstractDeclaredStatement<Status>
implements StatusStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .STATUS)
+ .build();
protected StatusStatementImpl(
StmtContext<Status, StatusStatement, ?> context) {
StmtContext<Status, StatusStatement, EffectiveStatement<Status, StatusStatement>> ctx) {
return new StatusEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Status, StatusStatement,
+ EffectiveStatement<Status, StatusStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.util.Collection;
+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;
import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public class StringRestrictionsImpl extends AbstractDeclaredStatement<String> implements
TypeStatement.StringRestrictions {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.LENGTH, 0, 1)
+ .add(Rfc6020Mapping.PATTERN, 0, MAX)
+ .build();
protected StringRestrictionsImpl(StmtContext<String, TypeStatement.StringRestrictions, ?> context) {
super(context);
StmtContext<String, TypeStatement.StringRestrictions, EffectiveStatement<String, TypeStatement.StringRestrictions>> ctx) {
return new StringRestrictionsEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, StringRestrictions,
+ EffectiveStatement<String, StringRestrictions>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
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 org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
-
+import com.google.common.base.Optional;
import java.net.URI;
import java.util.Date;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleName;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.SubmoduleEffectiveStatementImpl;
-import com.google.common.base.Optional;
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)
+ .build();
protected SubmoduleStatementImpl(
StmtContext<String, SubmoduleStatement, ?> context) {
stmt.addToNs(BelongsToPrefixToModuleName.class, prefix,
belongsToModuleName);
}
+
+ @Override
+ public void onFullDefinitionDeclared(Mutable<String, SubmoduleStatement,
+ EffectiveStatement<String, SubmoduleStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
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;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
public class TypeStatementImpl extends AbstractDeclaredStatement<String>
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)
+ .build();
protected TypeStatementImpl(final StmtContext<String, TypeStatement, ?> context) {
super(context);
public void onFullDefinitionDeclared(
final Mutable<String, TypeStatement, EffectiveStatement<String, TypeStatement>> stmt)
throws SourceException {
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
// if it is yang built-in type, no prerequisite is needed, so simply return
if (TypeUtils.isYangBuiltInTypeString(stmt.getStatementArgument())) {
public String getName() {
return argument();
}
-}
+}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.TypeDefEffectiveStatementImpl;
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)
+ .build();
protected TypedefStatementImpl(StmtContext<QName, TypedefStatement, ?> context) {
super(context);
stmt.getParentContext().addContext(TypeNamespace.class, stmt.getStatementArgument(), stmt);
}
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<QName, TypedefStatement,
+ EffectiveStatement<QName, TypedefStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nullable
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.util.Collection;
+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.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.UnionSpecificationEffectiveStatementImpl;
public class UnionSpecificationImpl extends AbstractDeclaredStatement<String>
implements TypeStatement.UnionSpecification {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .TYPE)
+ .add(Rfc6020Mapping.TYPE, 1, MAX)
+ .build();
protected UnionSpecificationImpl(
StmtContext<String, TypeStatement.UnionSpecification, ?> context) {
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) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UniqueEffectiveStatementImpl;
public class UniqueStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier.Relative>> implements UniqueStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .UNIQUE)
+ .build();
protected UniqueStatementImpl(StmtContext<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement, ?> context) {
super(context);
UniqueStatement>> ctx) {
return new UniqueEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Collection<Relative>, UniqueStatement,
+ EffectiveStatement<Collection<Relative>, UniqueStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnitsEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnitsEffectiveStatementImpl;
public class UnitsStatementImpl extends AbstractDeclaredStatement<String>
implements UnitsStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .UNITS)
+ .build();
protected UnitsStatementImpl(StmtContext<String, UnitsStatement, ?> context) {
super(context);
return new UnitsEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, UnitsStatement,
+ EffectiveStatement<String, UnitsStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
*/
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;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
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)
+ .build();
private static final Logger LOG = LoggerFactory.getLogger(UsesStatementImpl.class);
public void onFullDefinitionDeclared(
final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode)
throws SourceException {
+ SUBSTATEMENT_VALIDATOR.validate(usesNode);
if(StmtContextUtils.isInExtensionBody(usesNode)) {
return;
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ValueEffectiveStatementImpl;
public class ValueStatementImpl extends AbstractDeclaredStatement<Integer> implements ValueStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .VALUE)
+ .build();
protected ValueStatementImpl(StmtContext<Integer, ValueStatement, ?> context) {
super(context);
return new ValueEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Integer, ValueStatement,
+ EffectiveStatement<Integer, ValueStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.WhenEffectiveStatementImpl;
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)
+ .build();
protected WhenStatementImpl(final StmtContext<RevisionAwareXPath, WhenStatement, ?> context) {
super(context);
final StmtContext<RevisionAwareXPath, WhenStatement, EffectiveStatement<RevisionAwareXPath, WhenStatement>> ctx) {
return new WhenEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, WhenStatement,
+ EffectiveStatement<RevisionAwareXPath, WhenStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangVersionEffectiveStatementImpl;
-
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangVersionEffectiveStatementImpl;
public class YangVersionStatementImpl extends AbstractDeclaredStatement<String> implements YangVersionStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .YANG_VERSION)
+ .build();
protected YangVersionStatementImpl(StmtContext<String, YangVersionStatement, ?> context) {
super(context);
}
- public static class Definition extends AbstractStatementSupport<String,YangVersionStatement,EffectiveStatement<String,YangVersionStatement>> {
+ public static class Definition extends AbstractStatementSupport<String,YangVersionStatement,
+ EffectiveStatement<String,YangVersionStatement>> {
public Definition() {
super(Rfc6020Mapping.YANG_VERSION);
}
@Override
- public EffectiveStatement<String, YangVersionStatement> createEffective(StmtContext<String, YangVersionStatement, EffectiveStatement<String, YangVersionStatement>> ctx) {
+ public EffectiveStatement<String, YangVersionStatement> createEffective
+ (StmtContext<String, YangVersionStatement, EffectiveStatement<String, YangVersionStatement>> ctx) {
return new YangVersionEffectiveStatementImpl(ctx);
}
+
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, YangVersionStatement,
+ EffectiveStatement<String, YangVersionStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Nonnull @Override
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YinElementEffectiveStatementImpl;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YinElementEffectiveStatementImpl;
public class YinElementStatementImpl extends AbstractDeclaredStatement<Boolean>
implements YinElementStatement {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
+ .YIN_ELEMENT)
+ .build();
protected YinElementStatementImpl(
StmtContext<Boolean, YinElementStatement, ?> context) {
return new YinElementEffectiveStatementImpl(ctx);
}
+ @Override
+ public void onFullDefinitionDeclared(StmtContext.Mutable<Boolean, YinElementStatement,
+ EffectiveStatement<Boolean, YinElementStatement>> stmt) throws SourceException {
+ super.onFullDefinitionDeclared(stmt);
+ SUBSTATEMENT_VALIDATOR.validate(stmt);
+ }
}
@Override
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.yang.stmt.test;
+
+import static junit.framework.Assert.assertTrue;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URISyntaxException;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
+import org.opendaylight.yangtools.yang.stmt.retest.TestUtils;
+
+public class SubstatementValidatorTest {
+
+ private final PrintStream stdout = System.out;
+ private final ByteArrayOutputStream output = new ByteArrayOutputStream();
+ private String testLog;
+
+ @Rule
+ public ExpectedException expectedEx = ExpectedException.none();
+
+ @Before
+ public void setUp() throws UnsupportedEncodingException {
+ System.setOut(new PrintStream(output, true, "UTF-8"));
+ }
+
+ @After
+ public void cleanUp() {
+ System.setOut(stdout);
+ }
+
+ @Test
+ public void noException() throws URISyntaxException, ReactorException {
+ Set<Module> modules = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-augment").toURI());
+ assertNotNull(modules);
+ }
+
+ @Test
+ public void undesirableElementException() throws URISyntaxException, ReactorException {
+ Set<Module> modules = TestUtils.loadModules(getClass().getResource
+ ("/substatement-validator/undesirable-element").toURI());
+ testLog = output.toString();
+ assertTrue(testLog.contains("TYPE is not valid for REVISION"));
+ }
+
+ @Test
+ public void maximalElementCountException() throws URISyntaxException, ReactorException {
+ Set<Module> modules = TestUtils.loadModules(getClass().getResource
+ ("/substatement-validator/maximal-element").toURI());
+ testLog = output.toString();
+ assertTrue(testLog.contains("Maximal count of DESCRIPTION for AUGMENT is 1"));
+ }
+
+ @Test
+ public void missingElementException() throws URISyntaxException, ReactorException {
+ expectedEx.expect(IllegalStateException.class);
+
+ Set<Module> modules = TestUtils.loadModules(getClass().getResource
+ ("/substatement-validator/missing-element").toURI());
+ }
+
+ @Test
+ public void emptyElementException() throws URISyntaxException, ReactorException {
+ expectedEx.expect(NoSuchElementException.class);
+
+ Set<Module> modules = TestUtils.loadModules(getClass().getResource
+ ("/substatement-validator/empty-element").toURI());
+ }
+
+ @Test
+ public void bug4310test() throws URISyntaxException, ReactorException {
+ expectedEx.expect(IllegalArgumentException.class);
+
+ Set<Module> modules = TestUtils.loadModules(getClass().getResource
+ ("/substatement-validator/bug-4310").toURI());
+ }
+}
\ No newline at end of file
namespace root;
prefix root;
- import imported;
+ import imported {
+ prefix "imp";
+ }
augment "/aug1/aug11/aug111" {
container add {
deviation /cont {
deviate add {
- container subcont {
- }
}
reference "deviate reference";
}
default "auto-sense-speed";
}
- type union {
- type int32;
- type string;
- }
-
grouping grp1 {
leaf myenum {
type enumeration {
--- /dev/null
+module bug4310 {
+ yang-version 1;
+ namespace "urn:opendaylight.bug4310";
+ prefix "bug";
+
+ organization "opendaylight";
+ contact "http://www.opendaylight.org/";
+
+ leaf datapath-id {
+ type union {
+ bug:simple-ext-w-arg "key:value";
+ }
+ }
+
+ extension simple-ext-w-arg {
+ argument "ext-arg";
+ description "Extension with single argument definition.";
+ }
+}
\ No newline at end of file
--- /dev/null
+module empty {
+ namespace "root-module";
+ prefix empty;
+
+ container root-container {
+ uses grp-1 {
+ refine container-from-grouping/list-in-container {
+ }
+ }
+ }
+
+ grouping grp-1 {
+ container container-from-grouping {
+ list list-in-container {
+ description "original description";
+ }
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+module baz {
+ yang-version 1;
+ namespace "urn:opendaylight.baz";
+ prefix "baz";
+
+ import maximal {
+ prefix "max";
+ revision-date 2015-11-11;
+ }
+
+ organization "opendaylight";
+ contact "http://www.opendaylight.org/";
+
+ revision "2015-11-11" {
+ reference " WILL BE DEFINED LATER";
+ }
+
+ augment "/max:interfaces/max:ifEntry" {
+ description "Test describtion";
+ description "Test describtion";
+ container augment-holder2 {
+ description "Description for augment holder";
+ }
+ }
+}
--- /dev/null
+module maximal {
+ yang-version 1;
+ namespace "urn:opendaylight.maximal";
+ prefix "maximal";
+
+ organization "opendaylight";
+ contact "http://www.opendaylight.org/";
+
+ revision "2015-11-11" {
+ reference "WILL BE DEFINED LATER";
+ }
+
+ container interfaces {
+ grouping ifEntry {
+ container augment-holder;
+ }
+ list ifEntry {
+ key "ifIndex";
+
+ leaf ifIndex {
+ type uint32;
+ units minutes;
+ }
+
+ leaf ifMtu {
+ type int32;
+ }
+
+ min-elements 1;
+ max-elements 11;
+ }
+ }
+}
--- /dev/null
+module baz {
+ yang-version 1;
+ namespace "urn:opendaylight.baz";
+ prefix "baz";
+
+ import missing {
+ revision-date 2015-11-11;
+ }
+
+ organization "opendaylight";
+ contact "http://www.opendaylight.org/";
+
+ revision "2015-11-11" {
+ reference " WILL BE DEFINED LATER";
+ }
+}
\ No newline at end of file
--- /dev/null
+module missing {
+ yang-version 1;
+ namespace "urn:opendaylight.missing";
+ prefix "missing";
+
+ organization "opendaylight";
+ contact "http://www.opendaylight.org/";
+
+ revision "2015-11-11" {
+ reference " WILL BE DEFINED LATER";
+ }
+}
\ No newline at end of file
--- /dev/null
+module undesirable {
+ yang-version 1;
+ namespace "urn:opendaylight.undesirable";
+ prefix "undesirable";
+
+ organization "opendaylight";
+ contact "http://www.opendaylight.org/";
+
+ revision "2015-11-11" {
+ reference " WILL BE DEFINED LATER";
+ type "string";
+ }
+}
\ No newline at end of file
leaf leaf-identityref {
type identityref {
base "test-identity";
- units "test-unit";
}
}
type decimal64 {
fraction-digits 2;
range "1 .. 3.14 | 10 | 20..max";
- description "test decimal64";
- reference "test decimal64 ref";
- status current;
}
}
description "test bit";
reference "test bit ref";
status current;
- value 0;
}
bit two {
position 1;
- value 1;
}
bit three {
position 2;
description "test bit";
reference "test bit ref";
status current;
- value 0;
}
}
default "one";
Code Review / yangtools.git / commitdiff