import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
/**
private final StatementDefinition type;
- protected AbstractStatementSupport(StatementDefinition publicDefinition) {
+ protected AbstractStatementSupport(final StatementDefinition publicDefinition) {
Preconditions.checkArgument(publicDefinition != this);
this.type = Preconditions.checkNotNull(publicDefinition);
}
public abstract A parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws SourceException;
@Override
- public void onStatementAdded(StmtContext.Mutable<A, D, E> stmt) {
+ public void onStatementAdded(
final StmtContext.Mutable<A, D, E> stmt) {
// NOOP for most implementations
}
*
*/
@Override
- public void onPreLinkageDeclared(StmtContext.Mutable<A, D, E> stmt) {
+ public void onPreLinkageDeclared(
final StmtContext.Mutable<A, D, E> stmt) {
// NOOP for most implementations
}
*
*/
@Override
- public void onLinkageDeclared(StmtContext.Mutable<A, D, E> stmt) throws SourceException {
+ public void onLinkageDeclared(
final StmtContext.Mutable<A, D, E> stmt) throws SourceException {
// NOOP for most implementations
}
*
*/
@Override
- public void onStatementDefinitionDeclared(StmtContext.Mutable<A, D, E> stmt) throws SourceException {
+ public void onStatementDefinitionDeclared(
final StmtContext.Mutable<A, D, E> stmt) throws SourceException {
// NOOP for most implementations
}
*
*/
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<A, D, E> stmt) throws SourceException {
+ public void onFullDefinitionDeclared(
final StmtContext.Mutable<A, D, E> stmt) throws SourceException {
// NOOP for most implementations
}
public boolean isArgumentYinElement() {
return getPublicView().isArgumentYinElement();
}
+
+ /**
+ * Returns corresponding substatement validator of a statement support
+ *
+ * @return substatement validator or null, if substatement validator is not
+ * defined
+ */
+ @Nullable
+ protected abstract SubstatementValidator getSubstatementValidator();
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
+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;
@Beta
public final class AnyxmlSchemaLocationStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements
UnknownStatement<SchemaNodeIdentifier> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ SupportedExtensionsMapping.ANYXML_SCHEMA_LOCATION).build();
AnyxmlSchemaLocationStatementImpl(
- StmtContext<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, ?> context) {
+ final StmtContext<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, ?> context) {
super(context);
}
}
@Override
- public SchemaNodeIdentifier parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return Utils.nodeIdentifierFromPath(ctx, value);
}
@Override
public void onFullDefinitionDeclared(
- Mutable<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, EffectiveStatement<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>>> stmt) {
+ final Mutable<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, EffectiveStatement<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>>> stmt) {
+ getSubstatementValidator().validate(stmt);
stmt.getParentContext().addToNs(AnyxmlSchemaLocationNamespace.class,
SupportedExtensionsMapping.ANYXML_SCHEMA_LOCATION, stmt);
}
@Override
public UnknownStatement<SchemaNodeIdentifier> createDeclared(
- StmtContext<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, ?> ctx) {
+ final StmtContext<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, ?> ctx) {
return new AnyxmlSchemaLocationStatementImpl(ctx);
}
final StmtContext<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, EffectiveStatement<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>>> ctx) {
return new AnyxmlSchemaLocationEffectiveStatementImpl(ctx);
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
}
@Override
@Override
public EffectiveStatement<QName, AnyxmlStatement> createEffective(
final StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx) {
- Map<StatementDefinition, Mutable<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, EffectiveStatement<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>>>> schemaLocations = ctx
+ final Map<StatementDefinition, Mutable<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>, EffectiveStatement<SchemaNodeIdentifier, UnknownStatement<SchemaNodeIdentifier>>>> schemaLocations = ctx
.getAllFromCurrentStmtCtxNamespace(AnyxmlSchemaLocationNamespace.class);
if (schemaLocations != null && !schemaLocations.isEmpty()) {
- SchemaNodeIdentifier anyXmlSchemaNodeIdentifier = schemaLocations.values().iterator().next()
+ final SchemaNodeIdentifier anyXmlSchemaNodeIdentifier = schemaLocations.values().iterator().next()
.getStatementArgument();
- Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(ctx, anyXmlSchemaNodeIdentifier);
+ final Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(ctx, anyXmlSchemaNodeIdentifier);
if (anyXmlSchema.isPresent()) {
return new YangModeledAnyXmlEffectiveStatementImpl(ctx, anyXmlSchema.get());
}
public void onFullDefinitionDeclared(final Mutable<QName, AnyxmlStatement,
EffectiveStatement<QName, AnyxmlStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
}
private Optional<ContainerSchemaNode> getAnyXmlSchema(
}
return Optional.absent();
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
}
@Nonnull
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, ArgumentStatement,
EffectiveStatement<QName, ArgumentStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
return;
}
- SUBSTATEMENT_VALIDATOR.validate(augmentNode);
+ getSubstatementValidator().validate(augmentNode);
if (StmtContextUtils.isInExtensionBody(augmentNode)) {
return;
|| allowedAugmentTargets.contains(substatementCtx.getPublicDefinition());
}
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
}
@Nonnull
public void onFullDefinitionDeclared(
final Mutable<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, BelongsToStatement,
EffectiveStatement<String, BelongsToStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, BitStatement,
EffectiveStatement<QName, BitStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, BitsSpecification,
EffectiveStatement<String, BitsSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, CaseStatement,
EffectiveStatement<QName, CaseStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, ChoiceStatement,
EffectiveStatement<QName, ChoiceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<Boolean, ConfigStatement,
EffectiveStatement<Boolean, ConfigStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ContactStatement,
EffectiveStatement<String, ContactStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, Decimal64Specification,
EffectiveStatement<String, Decimal64Specification>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, DefaultStatement,
EffectiveStatement<String, DefaultStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, DescriptionStatement,
EffectiveStatement<String, DescriptionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<DeviateKind, DeviateStatement,
EffectiveStatement<DeviateKind, DeviateStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, EnumSpecification,
EffectiveStatement<String, EnumSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, EnumStatement,
EffectiveStatement<String, EnumStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ErrorAppTagStatement,
EffectiveStatement<String, ErrorAppTagStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ErrorMessageStatement,
EffectiveStatement<String, ErrorMessageStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, ExtensionStatement,
EffectiveStatement<QName, ExtensionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, FeatureStatement,
EffectiveStatement<QName, FeatureStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<Integer, FractionDigitsStatement,
EffectiveStatement<Integer, FractionDigitsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
@Override
public void onFullDefinitionDeclared(final Mutable<QName, GroupingStatement,
EffectiveStatement<QName, GroupingStatement>> stmt) {
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
if (stmt != null && stmt.getParentContext() != null) {
stmt.getParentContext().addContext(GroupingNamespace.class, stmt.getStatementArgument(), stmt);
}
}
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
}
@Nonnull
public void onStatementDefinitionDeclared(final StmtContext.Mutable<String, IdentityRefSpecification,
EffectiveStatement<String, IdentityRefSpecification>> stmt) {
super.onStatementDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement,
EffectiveStatement<QName, IdentityStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, IfFeatureStatement,
EffectiveStatement<QName, IfFeatureStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, InputStatement,
EffectiveStatement<QName, InputStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, InstanceIdentifierSpecification,
EffectiveStatement<String, InstanceIdentifierSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<Collection<SchemaNodeIdentifier>, KeyStatement,
EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
}
public void onFullDefinitionDeclared(final Mutable<QName, LeafListStatement,
EffectiveStatement<QName, LeafListStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, LeafStatement,
EffectiveStatement<QName, LeafStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, LeafrefSpecification,
EffectiveStatement<String, LeafrefSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<List<LengthConstraint>,
LengthStatement, EffectiveStatement<List<LengthConstraint>, LengthStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, ListStatement,
EffectiveStatement<QName, ListStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<Boolean, MandatoryStatement,
EffectiveStatement<Boolean, MandatoryStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, MaxElementsStatement,
EffectiveStatement<String, MaxElementsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<Integer, MinElementsStatement,
EffectiveStatement<Integer, MinElementsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
+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.source.SourceException;
public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) throws SourceException {
return definition.parseArgumentValue(ctx, value);
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return null;
+ }
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<RevisionAwareXPath, MustStatement,
EffectiveStatement<RevisionAwareXPath, MustStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<URI, NamespaceStatement,
EffectiveStatement<URI, NamespaceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, NotificationStatement,
EffectiveStatement<QName, NotificationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, NumericalRestrictions,
EffectiveStatement<String, NumericalRestrictions>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, OrderedByStatement,
EffectiveStatement<String, OrderedByStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, OrganizationStatement,
EffectiveStatement<String, OrganizationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, OutputStatement,
EffectiveStatement<QName, OutputStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, PathStatement,
EffectiveStatement<RevisionAwareXPath, PathStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<PatternConstraint, PatternStatement,
EffectiveStatement<PatternConstraint, PatternStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(
final StmtContext.Mutable<Long, PositionStatement, EffectiveStatement<Long, PositionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, PrefixStatement,
EffectiveStatement<String, PrefixStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, PresenceStatement,
EffectiveStatement<String, PresenceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<List<RangeConstraint>, RangeStatement,
EffectiveStatement<List<RangeConstraint>, RangeStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ReferenceStatement,
EffectiveStatement<String, ReferenceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, RefineStatement,
EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<Boolean, RequireInstanceStatement,
EffectiveStatement<Boolean, RequireInstanceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(
final StmtContext.Mutable<Date, RevisionDateStatement, EffectiveStatement<Date, RevisionDateStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(
final StmtContext.Mutable<Date, RevisionStatement, EffectiveStatement<Date, RevisionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
@Override
public void onFullDefinitionDeclared(final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
+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.SemanticVersionNamespace;
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.SemanticVersionEffectiveStatementImpl;
@Beta
public final class SemanticVersionStatementImpl extends AbstractDeclaredStatement<SemVer> implements
UnknownStatement<SemVer> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ SupportedExtensionsMapping.SEMANTIC_VERSION).build();
SemanticVersionStatementImpl(
- StmtContext<SemVer, UnknownStatement<SemVer>, ?> context) {
+ final StmtContext<SemVer, UnknownStatement<SemVer>, ?> context) {
super(context);
}
}
@Override
- public SemVer parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public SemVer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return SemVer.valueOf(value) ;
}
@Override
- public void onLinkageDeclared(StmtContext.Mutable<SemVer,UnknownStatement<SemVer>,EffectiveStatement<SemVer,UnknownStatement<SemVer>>> stmt) {
+ public void onLinkageDeclared(final StmtContext.Mutable<SemVer,UnknownStatement<SemVer>,EffectiveStatement<SemVer,UnknownStatement<SemVer>>> stmt) {
stmt.addToNs(SemanticVersionNamespace.class, stmt.getParentContext(), stmt.getStatementArgument());
}
+ @Override
+ public void onFullDefinitionDeclared(
+ final Mutable<SemVer, UnknownStatement<SemVer>, EffectiveStatement<SemVer, UnknownStatement<SemVer>>> stmt)
+ throws SourceException {
+ getSubstatementValidator().validate(stmt);
+ }
+
@Override
public UnknownStatement<SemVer> createDeclared(
- StmtContext<SemVer, UnknownStatement<SemVer>, ?> ctx) {
+ final StmtContext<SemVer, UnknownStatement<SemVer>, ?> ctx) {
return new SemanticVersionStatementImpl(ctx);
}
final StmtContext<SemVer, UnknownStatement<SemVer>, EffectiveStatement<SemVer, UnknownStatement<SemVer>>> ctx) {
return new SemanticVersionEffectiveStatementImpl(ctx);
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Status, StatusStatement,
EffectiveStatement<Status, StatusStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, StringRestrictions,
EffectiveStatement<String, StringRestrictions>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<String, SubmoduleStatement,
EffectiveStatement<String, SubmoduleStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
@Override
public void onFullDefinitionDeclared(
final Mutable<String, TypeStatement, EffectiveStatement<String, TypeStatement>> stmt){
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
// if it is yang built-in type, no prerequisite is needed, so simply return
if (TypeUtils.isYangBuiltInTypeString(stmt.getStatementArgument())) {
}
});
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
}
@Nonnull
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, TypedefStatement,
EffectiveStatement<QName, TypedefStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
if (stmt != null && stmt.getParentContext() != null) {
final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> existing = stmt.getParentContext()
.getFromNamespace(TypeNamespace.class, stmt.getStatementArgument());
stmt.getParentContext().addContext(TypeNamespace.class, stmt.getStatementArgument(), stmt);
}
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
}
@Nullable
@Override
public void onFullDefinitionDeclared(final StmtContext.Mutable<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<Collection<Relative>, UniqueStatement,
EffectiveStatement<Collection<Relative>, UniqueStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(StmtContext.Mutable<String, UnitsStatement,
EffectiveStatement<String, UnitsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
+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;
final StmtContext<String, UnknownStatement<String>, EffectiveStatement<String, UnknownStatement<String>>> ctx) {
return new UnknownEffectiveStatementImpl(ctx);
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return null;
+ }
}
@Nullable
return;
}
- SUBSTATEMENT_VALIDATOR.validate(usesNode);
+ getSubstatementValidator().validate(usesNode);
if (StmtContextUtils.isInExtensionBody(usesNode)) {
return;
}
- ModelActionBuilder usesAction = usesNode.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
+ final ModelActionBuilder usesAction = usesNode.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
final QName groupingName = usesNode.getStatementArgument();
final Prerequisite<StmtContext<?, ?, ?>> sourceGroupingPre = usesAction.requiresCtx(usesNode,
@Override
public void apply() {
- StatementContextBase<?, ?, ?> targetNodeStmtCtx = (StatementContextBase<?, ?, ?>) targetNodePre.get();
- StatementContextBase<?, ?, ?> sourceGrpStmtCtx = (StatementContextBase<?, ?, ?>) sourceGroupingPre.get();
+ final StatementContextBase<?, ?, ?> targetNodeStmtCtx = (StatementContextBase<?, ?, ?>) targetNodePre.get();
+ final StatementContextBase<?, ?, ?> sourceGrpStmtCtx = (StatementContextBase<?, ?, ?>) sourceGroupingPre.get();
try {
copyFromSourceToTarget(sourceGrpStmtCtx, targetNodeStmtCtx, usesNode);
resolveUsesNode(usesNode, targetNodeStmtCtx);
- } catch (SourceException e) {
+ } catch (final SourceException e) {
LOG.warn(e.getMessage(), e);
throw e;
}
return new UsesEffectiveStatementImpl(ctx);
}
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
}
@Nonnull
public void onFullDefinitionDeclared(
final StmtContext.Mutable<Integer, ValueStatement, EffectiveStatement<Integer, ValueStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<RevisionAwareXPath, WhenStatement,
EffectiveStatement<RevisionAwareXPath, WhenStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<YangVersion, YangVersionStatement,
EffectiveStatement<YangVersion, YangVersionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final StmtContext.Mutable<Boolean, YinElementStatement,
EffectiveStatement<Boolean, YinElementStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
public void onFullDefinitionDeclared(final Mutable<QName, AnydataStatement,
EffectiveStatement<QName, AnydataStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
- SUBSTATEMENT_VALIDATOR.validate(stmt);
+ getSubstatementValidator().validate(stmt);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
+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;
final StmtContext<String, UnknownStatement<String>, EffectiveStatement<String, UnknownStatement<String>>> ctx) {
return new ThirdPartyExtensionEffectiveStatementImpl(ctx);
}
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return null;
+ }
}
@Override
Code Review / yangtools.git / commitdiff