abstract class AbstractIdentityAwareStatementSupport<D extends DeclaredStatement<QName>,
E extends EffectiveStatement<QName, D>> extends AbstractStatementSupport<QName, D, E> {
- private final SubstatementValidator validator;
-
AbstractIdentityAwareStatementSupport(final StatementDefinition publicDefinition,
- final YangParserConfiguration config) {
- super(publicDefinition, StatementPolicy.exactReplica(), config);
- validator = SubstatementValidator.builder(publicDefinition).build();
+ final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(publicDefinition, StatementPolicy.exactReplica(), config, validator);
}
@Override
});
}
- @Override
- protected final SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected final E createEffective(final Current<QName, D> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
SubstatementValidator.builder(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER).build();
public AugmentIdentifierStatementSupport(final YangParserConfiguration config) {
- super(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER, StatementPolicy.contextIndependent(), config);
+ super(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER, StatementPolicy.contextIndependent(), config,
+ VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
- }
-
@Override
protected AugmentIdentifierStatement createDeclared(
final StmtContext<UnqualifiedQName, AugmentIdentifierStatement, ?> ctx,
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
@Beta
public final class ContextInstanceStatementSupport
extends AbstractIdentityAwareStatementSupport<ContextInstanceStatement, ContextInstanceEffectiveStatement> {
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(OpenDaylightExtensionsStatements.CONTEXT_INSTANCE).build();
+
public ContextInstanceStatementSupport(final YangParserConfiguration config) {
- super(OpenDaylightExtensionsStatements.CONTEXT_INSTANCE, config);
+ super(OpenDaylightExtensionsStatements.CONTEXT_INSTANCE, config, VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
@Beta
public final class ContextReferenceStatementSupport
extends AbstractIdentityAwareStatementSupport<ContextReferenceStatement, ContextReferenceEffectiveStatement> {
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(OpenDaylightExtensionsStatements.CONTEXT_REFERENCE).build();
+
public ContextReferenceStatementSupport(final YangParserConfiguration config) {
- super(OpenDaylightExtensionsStatements.CONTEXT_REFERENCE, config);
+ super(OpenDaylightExtensionsStatements.CONTEXT_REFERENCE, config, VALIDATOR);
}
@Override
SubstatementValidator.builder(OpenDaylightExtensionsStatements.INSTANCE_TARGET).build();
public InstanceTargetStatementSupport(final YangParserConfiguration config) {
- super(OpenDaylightExtensionsStatements.INSTANCE_TARGET, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
+ super(OpenDaylightExtensionsStatements.INSTANCE_TARGET, StatementPolicy.contextIndependent(), config,
+ VALIDATOR);
}
@Override
SubstatementValidator.builder(OpenDaylightExtensionsStatements.RPC_CONTEXT_REFERENCE).build();
public RpcContextReferenceStatementSupport(final YangParserConfiguration config) {
- super(OpenDaylightExtensionsStatements.RPC_CONTEXT_REFERENCE, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
+ super(OpenDaylightExtensionsStatements.RPC_CONTEXT_REFERENCE, StatementPolicy.contextIndependent(), config,
+ VALIDATOR);
}
@Override
abstract class AbstractHashedValueStatementSupport
extends AbstractEmptyStatementSupport<OpenConfigHashedValueStatement, OpenConfigHashedValueEffectiveStatement> {
- private final SubstatementValidator validator;
-
- AbstractHashedValueStatementSupport(final StatementDefinition definition, final YangParserConfiguration config) {
- super(definition, StatementPolicy.contextIndependent(), config);
- this.validator = SubstatementValidator.builder(definition).build();
- }
-
- @Override
- protected final SubstatementValidator getSubstatementValidator() {
- return validator;
+ AbstractHashedValueStatementSupport(final StatementDefinition definition, final YangParserConfiguration config,
+ final SubstatementValidator validator) {
+ super(definition, StatementPolicy.contextIndependent(), config, validator);
}
@Override
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class EncryptedValueStatementSupport extends AbstractHashedValueStatementSupport {
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(OpenConfigStatements.OPENCONFIG_ENCRYPTED_VALUE).build();
+
public EncryptedValueStatementSupport(final YangParserConfiguration config) {
- super(OpenConfigStatements.OPENCONFIG_ENCRYPTED_VALUE, config);
+ super(OpenConfigStatements.OPENCONFIG_ENCRYPTED_VALUE, config, VALIDATOR);
}
}
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class HashedValueStatementSupport extends AbstractHashedValueStatementSupport {
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(OpenConfigStatements.OPENCONFIG_HASHED_VALUE).build();
+
public HashedValueStatementSupport(final YangParserConfiguration config) {
- super(OpenConfigStatements.OPENCONFIG_HASHED_VALUE, config);
+ super(OpenConfigStatements.OPENCONFIG_HASHED_VALUE, config, VALIDATOR);
}
}
</parent>
<artifactId>rfc6241-parser-support</artifactId>
- <version>7.0.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>${project.artifactId}</name>
<description>RFC6241 parser support</description>
SubstatementValidator.builder(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES).build();
public GetFilterElementAttributesStatementSupport(final YangParserConfiguration config) {
- super(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES, StatementPolicy.reject(), config);
+ super(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES, StatementPolicy.reject(), config, VALIDATOR);
}
@Override
stmt.setIsSupportedToBuildEffective(computeSupported(stmt));
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
- }
-
@Override
protected GetFilterElementAttributesStatement createDeclared(
final StmtContext<Empty, GetFilterElementAttributesStatement, ?> ctx,
SubstatementValidator.builder(NACMStatements.DEFAULT_DENY_ALL).build();
public DefaultDenyAllStatementSupport(final YangParserConfiguration config) {
- super(NACMStatements.DEFAULT_DENY_ALL, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
+ super(NACMStatements.DEFAULT_DENY_ALL, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
SubstatementValidator.builder(NACMStatements.DEFAULT_DENY_WRITE).build();
public DefaultDenyWriteStatementSupport(final YangParserConfiguration config) {
- super(NACMStatements.DEFAULT_DENY_WRITE, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
+ super(NACMStatements.DEFAULT_DENY_WRITE, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
@Beta
public final class AliasStatementSupport
extends AbstractStringStatementSupport<AliasStatement, AliasEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.ALIAS)
.add(YangStmtMapping.DESCRIPTION, 0, 1)
.add(YangStmtMapping.REFERENCE, 0, 1)
.build();
public AliasStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.ALIAS, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(IetfYangSmiv2ExtensionsMapping.ALIAS, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
@Beta
public final class DefValStatementSupport
extends AbstractStringStatementSupport<DefValStatement, DefValEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.DEFVAL).build();
public DefValStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.DEFVAL, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(IetfYangSmiv2ExtensionsMapping.DEFVAL, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
@Beta
public final class DisplayHintStatementSupport
extends AbstractStringStatementSupport<DisplayHintStatement, DisplayHintEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT).build();
public DisplayHintStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
@Beta
public final class ImpliedStatementSupport
extends AbstractStringStatementSupport<ImpliedStatement, ImpliedEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.IMPLIED).build();
public ImpliedStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.IMPLIED, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(IetfYangSmiv2ExtensionsMapping.IMPLIED, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
@Beta
public final class MaxAccessStatementSupport
extends AbstractStatementSupport<MaxAccess, MaxAccessStatement, MaxAccessEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS).build();
public MaxAccessStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS, StatementPolicy.contextIndependent(), config);
+ super(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
return val == null ? rawArgument : val.stringLiteral();
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected MaxAccessStatement createDeclared(final StmtContext<MaxAccess, MaxAccessStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
@Beta
public final class OidStatementSupport
extends AbstractStatementSupport<ObjectIdentifier, OidStatement, OidEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.OBJECT_ID).build();
public OidStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.OBJECT_ID, StatementPolicy.contextIndependent(), config);
+ super(IetfYangSmiv2ExtensionsMapping.OBJECT_ID, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected OidStatement createDeclared(final StmtContext<ObjectIdentifier, OidStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
@Beta
public final class SubIdStatementSupport
extends AbstractStatementSupport<Uint32, SubIdStatement, SubIdEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.SUB_ID).build();
public SubIdStatementSupport(final YangParserConfiguration config) {
- super(IetfYangSmiv2ExtensionsMapping.SUB_ID, StatementPolicy.contextIndependent(), config);
+ super(IetfYangSmiv2ExtensionsMapping.SUB_ID, StatementPolicy.contextIndependent(), config, VALIDATOR);
}
@Override
return Uint32.valueOf(value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected SubIdStatement createDeclared(final StmtContext<Uint32, SubIdStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.build();
public AnnotationStatementSupport(final YangParserConfiguration config) {
- super(MetadataStatements.ANNOTATION, StatementPolicy.reject(), config);
+ super(MetadataStatements.ANNOTATION, StatementPolicy.reject(), config, VALIDATOR);
}
@Override
stmt, "Annotations may only be defined at root of either a module or a submodule");
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
- }
-
@Override
protected AnnotationStatement createDeclared(final StmtContext<QName, AnnotationStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
@Beta
public final class YangDataStatementSupport
extends AbstractStringStatementSupport<YangDataStatement, YangDataEffectiveStatement> {
- private final SubstatementValidator declaredValidator;
+ private static final SubstatementValidator VALIDATOR = SubstatementValidator.builder(YangDataStatements.YANG_DATA)
+ .addMandatory(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.USES)
+ .build();
public YangDataStatementSupport(final YangParserConfiguration config) {
- super(YangDataStatements.YANG_DATA, StatementPolicy.reject(), config);
- declaredValidator = SubstatementValidator.builder(YangDataStatements.YANG_DATA)
- .addMandatory(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.USES)
- .build();
+ super(YangDataStatements.YANG_DATA, StatementPolicy.reject(), config, VALIDATOR);
}
@Override
return true;
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return declaredValidator;
- }
-
@Override
protected YangDataStatement createDeclared(@NonNull final StmtContext<String, YangDataStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
// Implied by UnknownSchemaNode
&& copy.history().isAugmenting() == current.history().isAugmenting()
&& copy.history().isAddedByUses() == current.history().isAddedByUses()
- && copy.equalParentPath(current)), config);
+ && copy.equalParentPath(current)), config, VALIDATOR);
}
// FIXME: these two methods are not quite right. RFC8528 states that:
"Mount points may only be defined at either a container or a list");
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return VALIDATOR;
- }
-
@Override
protected MountPointStatement createDeclared(@NonNull final StmtContext<QName, MountPointStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(OpenConfigStatements.OPENCONFIG_VERSION).build();
public OpenConfigVersionSupport(final YangParserConfiguration config) {
- super(OpenConfigStatements.OPENCONFIG_VERSION, StatementPolicy.reject(), config);
+ super(OpenConfigStatements.OPENCONFIG_VERSION, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
stmt.addToNs(SemanticVersionNamespace.class, stmt.getParentContext(), stmt.argument());
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected OpenConfigVersionStatement createDeclared(final StmtContext<SemVer, OpenConfigVersionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
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.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
- AbstractAugmentStatementSupport(final YangParserConfiguration config) {
+ AbstractAugmentStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
super(YangStmtMapping.AUGMENT, StatementPolicy.copyDeclared(
(copy, current, substatements) ->
copy.getArgument().equals(current.getArgument())
&& copy.moduleName().getModule().equals(current.moduleName().getModule())
&& Objects.equals(copy.original(), current.original())
- ), config);
+ ), config, validator);
}
@Override
.build();
public AugmentStatementRFC6020Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
.build();
public AugmentStatementRFC7950Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
YangStmtMapping.MANDATORY, YangStmtMapping.MAX_ELEMENTS, YangStmtMapping.MIN_ELEMENTS);
AbstractDeviateStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.DEVIATE, StatementPolicy.contextIndependent(), config);
+ // Note: we are performing our own validation based on deviate kind.
+ // TODO: perhaps we should do argumentSpecificSupport?
+ super(YangStmtMapping.DEVIATE, StatementPolicy.contextIndependent(), config, null);
}
@Override
}
}
- @Override
- protected final SubstatementValidator getSubstatementValidator() {
- return null;
- }
-
@Override
protected final DeviateStatement createDeclared(final StmtContext<DeviateKind, DeviateStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
private final YangParserConfiguration config;
public ExtensionStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.EXTENSION, StatementPolicy.reject(), config);
+ super(YangStmtMapping.EXTENSION, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
this.config = requireNonNull(config);
}
config));
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected ExtensionStatement createDeclared(final StmtContext<QName, ExtensionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
import org.opendaylight.yangtools.yang.parser.spi.meta.OverrideChildStatementSupport;
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.SubstatementValidator;
final class UnrecognizedStatementSupport
extends AbstractStatementSupport<Object, UnrecognizedStatement, UnrecognizedEffectiveStatement>
UnrecognizedStatementSupport(final StatementDefinition publicDefinition, final YangParserConfiguration config) {
// We have no idea about the statement's semantics, hence there should be noone interested in its semantics.
// Nevertheless it may be of interest for various hacks to understand there was an extension involved.
- super(publicDefinition, StatementPolicy.exactReplica(), config);
+ super(publicDefinition, StatementPolicy.exactReplica(), config, null);
this.config = requireNonNull(config);
}
return new UnrecognizedStatementSupport(def, config);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- // We know nothing about this statement
- return null;
- }
-
@Override
protected UnrecognizedStatement createDeclared(final StmtContext<Object, UnrecognizedStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
abstract class AbstractIfFeatureStatementSupport
extends AbstractStatementSupport<IfFeatureExpr, IfFeatureStatement, IfFeatureEffectiveStatement> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractIfFeatureStatementSupport.class);
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.IF_FEATURE)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.IF_FEATURE).build();
AbstractIfFeatureStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.IF_FEATURE, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.IF_FEATURE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
});
}
- @Override
- protected final SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected final IfFeatureStatement createDeclared(final StmtContext<IfFeatureExpr, IfFeatureStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_PRE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
.addOptional(YangStmtMapping.REFERENCE)
.build();
- private final SubstatementValidator validator;
private final boolean semanticVersioning;
private ImportStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.IMPORT, StatementPolicy.reject(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.IMPORT, StatementPolicy.reject(), config, validator);
semanticVersioning = config.importResolutionMode() == ImportResolutionMode.OPENCONFIG_SEMVER;
}
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected ImportStatement createDeclared(final StmtContext<String, ImportStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
.addOptional(YangStmtMapping.WHEN)
.build();
- private final SubstatementValidator validator;
-
private LeafListStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.LEAF_LIST, instantiatedPolicy(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.LEAF_LIST, instantiatedPolicy(), config, validator);
}
public static @NonNull LeafListStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return new LeafListStatementSupport(config, RFC7950_VALIDATOR);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected LeafListStatement createDeclared(final StmtContext<QName, LeafListStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
import static com.google.common.base.Verify.verify;
-import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
.addOptional(YangStmtMapping.WHEN)
.build();
- private final SubstatementValidator validator;
-
ListStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.LIST, instantiatedPolicy(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.LIST, instantiatedPolicy(), config, validator);
}
public static @NonNull ListStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return new ListStatementSupport(config, RFC7950_VALIDATOR);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected ListStatement createDeclared(final StmtContext<QName, ListStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
/**
* A massively-misnamed superclass for statements which are both schema tree participants and can be created as implicit
*/
abstract class AbstractImplicitStatementSupport<D extends DeclaredStatement<QName>,
E extends SchemaTreeEffectiveStatement<D>> extends AbstractSchemaTreeStatementSupport<D, E> {
- AbstractImplicitStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<QName, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ AbstractImplicitStatementSupport(final StatementDefinition publicDefinition, final StatementPolicy<QName, D> policy,
+ final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(publicDefinition, policy, config, requireNonNull(validator));
}
@Override
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
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.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
/**
private final Function<QNameModule, QName> createArgument;
AbstractOperationContainerStatementSupport(final StatementDefinition publicDefinition,
- final YangParserConfiguration config, final Function<QNameModule, QName> createArgument) {
- super(publicDefinition, uninstantiatedPolicy(), config);
+ final YangParserConfiguration config, final SubstatementValidator validator,
+ final Function<QNameModule, QName> createArgument) {
+ super(publicDefinition, uninstantiatedPolicy(), config, validator);
this.createArgument = requireNonNull(createArgument);
}
public ActionStatementSupport(final YangParserConfiguration config, final InputStatementSupport implicitInput,
final OutputStatementSupport implicitOutput) {
- super(YangStmtMapping.ACTION, uninstantiatedPolicy(), config);
+ super(YangStmtMapping.ACTION, uninstantiatedPolicy(), config, SUBSTATEMENT_VALIDATOR);
this.implicitInput = requireNonNull(implicitInput);
this.implicitOutput = requireNonNull(implicitOutput);
}
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected ActionStatement createDeclared(final StmtContext<QName, ActionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.build();
public AnydataStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ANYDATA, instantiatedPolicy(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.ANYDATA, instantiatedPolicy(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
.build();
public AnyxmlStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ANYXML, instantiatedPolicy(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.ANYXML, instantiatedPolicy(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.ARGUMENT).addOptional(YangStmtMapping.YIN_ELEMENT).build();
public ArgumentStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ARGUMENT, StatementPolicy.reject(), config);
+ super(YangStmtMapping.ARGUMENT, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
return StmtContextUtils.parseIdentifier(ctx, value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected ArgumentStatement createDeclared(final StmtContext<QName, ArgumentStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.BASE).build();
public BaseStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.BASE, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.BASE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected BaseStatement createDeclared(final StmtContext<QName, BaseStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.BELONGS_TO).addMandatory(YangStmtMapping.PREFIX).build();
public BelongsToStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.BELONGS_TO, StatementPolicy.reject(), config);
+ super(YangStmtMapping.BELONGS_TO, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
BelongsToEffectiveStatement> belongsToCtx) {
return RevisionSourceIdentifier.create(belongsToCtx.getArgument());
}
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
}
.addOptional(YangStmtMapping.POSITION)
.build();
- private final SubstatementValidator validator;
-
private BitStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.BIT, StatementPolicy.contextIndependent(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.BIT, StatementPolicy.contextIndependent(), config, requireNonNull(validator));
}
public static @NonNull BitStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return StmtContextUtils.parseIdentifier(ctx, value).getLocalName();
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected BitStatement createDeclared(final StmtContext<String, BitStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
.addOptional(YangStmtMapping.WHEN)
.build();
- private final SubstatementValidator validator;
-
private CaseStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.CASE, instantiatedPolicy(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.CASE, instantiatedPolicy(), config, validator);
}
public static @NonNull CaseStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return new CaseStatementSupport(config, RFC7950_VALIDATOR);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected CaseStatement createDeclared(final StmtContext<QName, CaseStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.addOptional(YangStmtMapping.WHEN)
.build();
- private final SubstatementValidator validator;
private final CaseStatementSupport implicitCase;
private ChoiceStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator,
final CaseStatementSupport implicitCase) {
- super(YangStmtMapping.CHOICE, instantiatedPolicy(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.CHOICE, instantiatedPolicy(), config, requireNonNull(validator));
this.implicitCase = requireNonNull(implicitCase);
}
: Optional.empty();
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected ChoiceStatement createDeclared(@NonNull final StmtContext<QName, ChoiceStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
EffectiveStatements.createConfig(false), EffectiveStatements.createConfig(true),
// FIXME: This is not quite true. If we are instantiated in a context which ignores config, which should
// really fizzle. This needs some more analysis.
- StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.CONTACT).build();
public ContactStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.CONTACT, StatementPolicy.reject(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.CONTACT, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
.addOptional(YangStmtMapping.WHEN)
.build();
- private final SubstatementValidator validator;
-
private ContainerStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.CONTAINER, instantiatedPolicy(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.CONTAINER, instantiatedPolicy(), config, validator);
}
public static @NonNull ContainerStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return new ContainerStatementSupport(config, RFC7950_VALIDATOR);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected ContainerStatement createDeclared(final StmtContext<QName, ContainerStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public DefaultStatementSupport(final YangParserConfiguration config) {
// Note: if we start interpreting the string we'll need to use StatementPolicy.declaredCopy()
- super(YangStmtMapping.DEFAULT, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.DEFAULT, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.DESCRIPTION).build();
public DescriptionStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.DESCRIPTION, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.DESCRIPTION, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
public final class DeviationStatementSupport
extends AbstractStatementSupport<Absolute, DeviationStatement, DeviationEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .DEVIATION)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.DEVIATE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DEVIATION)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.DEVIATE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
public DeviationStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.DEVIATION, StatementPolicy.reject(), config);
+ super(YangStmtMapping.DEVIATION, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected DeviationStatement createDeclared(final StmtContext<Absolute, DeviationStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
.addOptional(YangStmtMapping.VALUE)
.build();
- private final SubstatementValidator validator;
-
private EnumStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.ENUM, StatementPolicy.contextIndependent(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.ENUM, StatementPolicy.contextIndependent(), config, validator);
}
public static @NonNull EnumStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return value;
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected EnumStatement createDeclared(final StmtContext<String, EnumStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public final class ErrorAppTagStatementSupport
extends AbstractStringStatementSupport<ErrorAppTagStatement, ErrorAppTagEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.ERROR_APP_TAG).build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ERROR_APP_TAG).build();
public ErrorAppTagStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ERROR_APP_TAG, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.ERROR_APP_TAG, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.ERROR_MESSAGE).build();
public ErrorMessageStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ERROR_MESSAGE, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.ERROR_MESSAGE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
.build();
public FeatureStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.FEATURE, StatementPolicy.reject(), config);
+ super(YangStmtMapping.FEATURE, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
stmt.addContext(FeatureNamespace.class, stmt.getArgument(), stmt);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected FeatureStatement createDeclared(final StmtContext<QName, FeatureStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
}
public FractionDigitsStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.FRACTION_DIGITS, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.FRACTION_DIGITS, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
return fractionDigits;
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected FractionDigitsStatement createDeclared(final StmtContext<Integer, FractionDigitsStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
.addAny(YangStmtMapping.USES)
.build();
- private final SubstatementValidator validator;
-
GroupingStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
super(YangStmtMapping.GROUPING, StatementPolicy.copyDeclared(
(copy, current, substatements) ->
copy.history().isAddedByUses() == current.history().isAddedByUses()
&& copy.getArgument().equals(current.getArgument())
- && copy.equalParentPath(current)), config);
- this.validator = requireNonNull(validator);
+ && copy.equalParentPath(current)), config, validator);
}
public static @NonNull GroupingStatementSupport rfc6020Instance(final YangParserConfiguration config) {
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected GroupingStatement createDeclared(final StmtContext<QName, GroupingStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
.addOptional(YangStmtMapping.STATUS)
.build();
- private final SubstatementValidator validator;
-
private IdentityStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.IDENTITY, StatementPolicy.reject(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.IDENTITY, StatementPolicy.reject(), config, validator);
}
public static @NonNull IdentityStatementSupport rfc6020Instance(final YangParserConfiguration config) {
stmt.addToNs(IdentityNamespace.class, qname, stmt);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected IdentityStatement createDeclared(final StmtContext<QName, IdentityStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
.addOptional(YangStmtMapping.REFERENCE)
.build();
- private final SubstatementValidator validator;
-
IncludeStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.INCLUDE, StatementPolicy.reject(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.INCLUDE, StatementPolicy.reject(), config, validator);
}
public static @NonNull IncludeStatementSupport rfc6020Instance(final YangParserConfiguration config) {
});
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected IncludeStatement createDeclared(final StmtContext<String, IncludeStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
.addAny(YangStmtMapping.USES)
.build();
- private final SubstatementValidator validator;
-
private InputStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.INPUT, config, YangConstants::operationInputQName);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.INPUT, config, validator, YangConstants::operationInputQName);
}
public static @NonNull InputStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return new InputStatementSupport(config, RFC7950_VALIDATOR);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected InputStatement createDeclared(final StmtContext<QName, InputStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public KeyStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.KEY, StatementPolicy.copyDeclared(
// Identity comparison is sufficient because adaptArgumentValue() is careful about reuse.
- (copy, current, substatements) -> copy.getArgument() == current.getArgument()), config);
+ (copy, current, substatements) -> copy.getArgument() == current.getArgument()),
+ config, SUBSTATEMENT_VALIDATOR);
}
@Override
return replaced ? builder.build() : ctx.argument();
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected KeyStatement createDeclared(final StmtContext<Set<QName>, KeyStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.build();
public LeafStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.LEAF, instantiatedPolicy(), config);
+ super(YangStmtMapping.LEAF, instantiatedPolicy(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
StmtContextUtils.validateIfFeatureAndWhenOnListKeys(ctx);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected LeafStatement createDeclared(final StmtContext<QName, LeafStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.build();
public LengthStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.LENGTH, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.LENGTH, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
return ImmutableList.copyOf(ranges);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected LengthStatement createDeclared(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
super(YangStmtMapping.MANDATORY,
EffectiveStatements.createMandatory(DeclaredStatements.createMandatory(Boolean.FALSE)),
EffectiveStatements.createMandatory(DeclaredStatements.createMandatory(Boolean.TRUE)),
- StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.MAX_ELEMENTS).build();
public MaxElementsStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.MAX_ELEMENTS, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.MAX_ELEMENTS, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
return "unbounded".equals(rawArgument) ? "unbounded" : rawArgument;
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected MaxElementsStatement createDeclared(final StmtContext<String, MaxElementsStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.MIN_ELEMENTS).build();
public MinElementsStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.MIN_ELEMENTS, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.MIN_ELEMENTS, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected MinElementsStatement createDeclared(final Integer argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.MODIFIER).build();
public ModifierStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.MODIFIER, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.MODIFIER, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
"'%s' is not valid argument of modifier statement", value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
public String internArgument(final String rawArgument) {
return "invert-match".equals(rawArgument) ? "invert-match" : rawArgument;
public MustStatementSupport(final XPathSupport xpathSupport, final YangParserConfiguration config) {
// Note: if we end up binding expressions, this needs to become declaredCopy()
- super(YangStmtMapping.MUST, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.MUST, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
this.xpathSupport = requireNonNull(xpathSupport);
}
return xpathSupport.parseXPath(ctx, value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected MustStatement createDeclared(final StmtContext<QualifiedBound, MustStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.NAMESPACE).build();
public NamespaceStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.NAMESPACE, StatementPolicy.reject(), config);
+ super(YangStmtMapping.NAMESPACE, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected NamespaceStatement createDeclared(@NonNull final StmtContext<XMLNamespace, NamespaceStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
EffectiveStatements.createOrderedBy(EMPTY_USER_DECL);
public OrderedByStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ORDERED_BY, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.ORDERED_BY, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected OrderedByStatement createDeclared(final StmtContext<Ordering, OrderedByStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.ORGANIZATION).build();
public OrganizationStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.ORGANIZATION, StatementPolicy.reject(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.ORGANIZATION, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
.addAny(YangStmtMapping.USES)
.build();
- private final SubstatementValidator validator;
-
private OutputStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.OUTPUT, config, YangConstants::operationOutputQName);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.OUTPUT, config, validator, YangConstants::operationOutputQName);
}
public static @NonNull OutputStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return new OutputStatementSupport(config, RFC7950_VALIDATOR);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected OutputStatement createDeclared(final StmtContext<QName, OutputStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.POSITION).build();
public PositionStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.POSITION, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.POSITION, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected PositionStatement createDeclared(final Uint32 argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.PREFIX).build();
public PrefixStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.PREFIX, StatementPolicy.reject(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.PREFIX, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.PRESENCE).build();
public PresenceStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.PRESENCE, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.PRESENCE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
.build();
public RangeStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.RANGE, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.RANGE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
return EffectiveStatements.createRange(stmt.declared(), substatements);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
private static @NonNull Number parseDecimalConstraintValue(final @NonNull StmtContext<?, ?, ?> ctx,
final @NonNull String value) {
if ("max".equals(value)) {
SubstatementValidator.builder(YangStmtMapping.REFERENCE).build();
public ReferenceStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.REFERENCE, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.REFERENCE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
public RequireInstanceStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.REQUIRE_INSTANCE,
EffectiveStatements.createRequireInstance(false), EffectiveStatements.createRequireInstance(true),
- StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.REVISION_DATE).build();
public RevisionDateStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.REVISION_DATE, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.REVISION_DATE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected RevisionDateStatement createDeclared(final StmtContext<Revision, RevisionDateStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.build();
public RevisionStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.REVISION, StatementPolicy.reject(), config);
+ super(YangStmtMapping.REVISION, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected RevisionStatement createDeclared(final StmtContext<Revision, RevisionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public RpcStatementSupport(final YangParserConfiguration config, final InputStatementSupport implicitInput,
final OutputStatementSupport implicitOutput) {
- super(YangStmtMapping.RPC, StatementPolicy.reject(), config);
+ super(YangStmtMapping.RPC, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
this.implicitInput = requireNonNull(implicitInput);
this.implicitOutput = requireNonNull(implicitOutput);
}
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected RpcStatement createDeclared(final StmtContext<QName, RpcStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.STATUS).build();
public StatusStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.STATUS, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.STATUS, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected StatusStatement createDeclared(final StmtContext<Status, StatusStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
.build();
public TypedefStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.TYPEDEF, StatementPolicy.exactReplica(), config);
+ super(YangStmtMapping.TYPEDEF, StatementPolicy.exactReplica(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected TypedefStatement createDeclared(final StmtContext<QName, TypedefStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public UniqueStatementSupport(final YangParserConfiguration config) {
// FIXME: This reflects what the current implementation does. We really want to define an adaptArgumentValue(),
// but how that plays with the argument and expectations needs to be investigated.
- super(YangStmtMapping.UNIQUE, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.UNIQUE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
return uniqueConstraints;
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected UniqueStatement createDeclared(final StmtContext<Set<Descendant>, UniqueStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.UNITS).build();
public UnitsStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.UNITS, StatementPolicy.contextIndependent(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(YangStmtMapping.UNITS, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
SubstatementValidator.builder(YangStmtMapping.VALUE).build();
public ValueStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.VALUE, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.VALUE, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected ValueStatement createDeclared(final Integer argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public final class WhenStatementSupport
extends AbstractStatementSupport<QualifiedBound, WhenStatement, WhenEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.WHEN)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.WHEN)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
private final @NonNull XPathSupport xpathSupport;
public WhenStatementSupport(final XPathSupport xpathSupport, final YangParserConfiguration config) {
// Note: if we end up binding expressions, this needs to become declaredCopy()
- super(YangStmtMapping.WHEN, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.WHEN, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
this.xpathSupport = requireNonNull(xpathSupport);
}
return xpathSupport.parseXPath(ctx, value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected WhenStatement createDeclared(final StmtContext<QualifiedBound, WhenStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
SubstatementValidator.builder(YangStmtMapping.YANG_VERSION).build();
public YangVersionStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.YANG_VERSION, StatementPolicy.reject(), config);
+ super(YangStmtMapping.YANG_VERSION, StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
stmt.setRootVersion(stmt.argument());
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected YangVersionStatement createDeclared(final StmtContext<YangVersion, YangVersionStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
public final class YinElementStatementSupport
extends AbstractBooleanStatementSupport<YinElementStatement, YinElementEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.YIN_ELEMENT).build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.YIN_ELEMENT).build();
public YinElementStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.YIN_ELEMENT,
EffectiveStatements.createYinElement(DeclaredStatements.createYinElement(false)),
EffectiveStatements.createYinElement(DeclaredStatements.createYinElement(true)),
- StatementPolicy.reject(), config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ StatementPolicy.reject(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import com.google.common.annotations.Beta;
.addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
.build();
- private final SubstatementValidator validator;
private final boolean semanticVersioning;
private ModuleStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.MODULE, StatementPolicy.reject(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.MODULE, StatementPolicy.reject(), config, validator);
semanticVersioning = config.importResolutionMode() == ImportResolutionMode.OPENCONFIG_SEMVER;
}
}
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
final Current<UnqualifiedQName, ModuleStatement> stmt,
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
abstract class AbstractNotificationStatementSupport
extends AbstractSchemaTreeStatementSupport<NotificationStatement, NotificationEffectiveStatement> {
- AbstractNotificationStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.NOTIFICATION, uninstantiatedPolicy(), config);
+ AbstractNotificationStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.NOTIFICATION, uninstantiatedPolicy(), config, validator);
}
@Override
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class NotificationStatementRFC6020Support extends AbstractNotificationStatementSupport {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.NOTIFICATION)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.NOTIFICATION)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
public NotificationStatementRFC6020Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
}
\ No newline at end of file
ImmutableSet.of(YangStmtMapping.NOTIFICATION, YangStmtMapping.RPC, YangStmtMapping.ACTION);
public NotificationStatementRFC7950Support(final YangParserConfiguration config) {
- super(config);
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
super.onStatementAdded(stmt);
}
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
}
private PathStatementSupport(final YangParserConfiguration config, final PathExpressionParser parser) {
// TODO: can 'path' really be copied?
- super(YangStmtMapping.PATH, StatementPolicy.contextIndependent(), config);
+ super(YangStmtMapping.PATH, StatementPolicy.contextIndependent(), config, SUBSTATEMENT_VALIDATOR);
this.parser = requireNonNull(parser);
}
return parser.parseExpression(ctx, value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected PathStatement createDeclared(final StmtContext<PathExpression, PathStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import java.util.regex.Pattern;
.addOptional(YangStmtMapping.REFERENCE)
.build();
- private final SubstatementValidator validator;
-
private PatternStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.PATTERN, StatementPolicy.contextIndependent(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.PATTERN, StatementPolicy.contextIndependent(), config, validator);
}
public static @NonNull PatternStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return PatternExpression.of(value, pattern);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected PatternStatement createDeclared(final StmtContext<PatternExpression, PatternStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
.addOptional(YangStmtMapping.MAX_ELEMENTS)
.build();
- private final SubstatementValidator validator;
-
private RefineStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.REFINE, StatementPolicy.reject(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.REFINE, StatementPolicy.reject(), config, validator);
}
public static @NonNull RefineStatementSupport rfc6020Instance(final YangParserConfiguration config) {
return ArgumentUtils.parseDescendantSchemaNodeIdentifier(ctx, value);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected RefineStatement createDeclared(final StmtContext<Descendant, RefineStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
-import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
.addOptional(YangStmtMapping.YANG_VERSION)
.build();
- private final SubstatementValidator validator;
-
private SubmoduleStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
- super(YangStmtMapping.SUBMODULE, StatementPolicy.reject(), config);
- this.validator = requireNonNull(validator);
+ super(YangStmtMapping.SUBMODULE, StatementPolicy.reject(), config, validator);
}
public static @NonNull SubmoduleStatementSupport rfc6020Instance(final YangParserConfiguration config) {
stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName);
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return validator;
- }
-
@Override
protected SubmoduleStatement createDeclared(final StmtContext<UnqualifiedQName, SubmoduleStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
private final ImmutableMap<String, StatementSupport<?, ?, ?>> dynamicBuiltInTypes;
AbstractTypeStatementSupport(final YangParserConfiguration config) {
- super(config);
+ super(config, SUBSTATEMENT_VALIDATOR);
dynamicBuiltInTypes = ImmutableMap.<String, StatementSupport<?, ?, ?>>builder()
.put(TypeDefinitions.BITS.getLocalName(), new BitsSpecificationSupport(config))
.put(TypeDefinitions.DECIMAL64.getLocalName(), new Decimal64SpecificationSupport(config))
.put(TypeDefinitions.ENUMERATION.getLocalName(), new EnumSpecificationSupport(config))
- .put(TypeDefinitions.IDENTITYREF.getLocalName(), new IdentityRefSpecificationRFC6020Support(config))
+ .put(TypeDefinitions.IDENTITYREF.getLocalName(), IdentityRefSpecificationSupport.rfc6020Instance(config))
.put(TypeDefinitions.INSTANCE_IDENTIFIER.getLocalName(), new InstanceIdentifierSpecificationSupport(config))
- .put(TypeDefinitions.LEAFREF.getLocalName(), new LeafrefSpecificationRFC6020Support(config))
+ .put(TypeDefinitions.LEAFREF.getLocalName(), LeafrefSpecificationSupport.rfc6020Instance(config))
.put(TypeDefinitions.UNION.getLocalName(), new UnionSpecificationSupport(config))
.build();
}
return dynamicBuiltInTypes.get(argument);
}
- @Override
- protected final SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected final TypeStatement createDeclared(final StmtContext<QName, TypeStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.util.List;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
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.meta.SubstatementValidator;
/**
* Abstract base of all type-related statement support classes.
TypeDefinitions.UNION),
QName::getLocalName);
- AbstractTypeSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.TYPE, StatementPolicy.exactReplica(), config);
+ AbstractTypeSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.TYPE, StatementPolicy.exactReplica(), config, requireNonNull(validator));
}
@Override
SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.BIT).build();
BitsSpecificationSupport(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
.build();
Decimal64SpecificationSupport(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
final class EnumSpecificationSupport extends AbstractTypeSupport<EnumSpecification> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.ENUM).build();
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.ENUM).build();
EnumSpecificationSupport(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
+++ /dev/null
-/*
- * Copyright (c) 2017 Pantheon Technologies, s.r.o. 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.rfc7950.stmt.type;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-
-final class IdentityRefSpecificationRFC6020Support extends AbstractIdentityRefSpecificationSupport {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.TYPE).addMandatory(YangStmtMapping.BASE).build();
-
- IdentityRefSpecificationRFC6020Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2017 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.rfc7950.stmt.type;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-
-/**
- * Class providing necessary support for processing YANG 1.1 identityref statement.
- */
-final class IdentityRefSpecificationRFC7950Support extends AbstractIdentityRefSpecificationSupport {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.BASE).build();
-
- IdentityRefSpecificationRFC7950Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-}
import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-abstract class AbstractIdentityRefSpecificationSupport
- extends AbstractTypeSupport<IdentityRefSpecification> {
- AbstractIdentityRefSpecificationSupport(final YangParserConfiguration config) {
- super(config);
+final class IdentityRefSpecificationSupport extends AbstractTypeSupport<IdentityRefSpecification> {
+ private static final SubstatementValidator RFC6020_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMandatory(YangStmtMapping.BASE).build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.BASE).build();
+
+ private IdentityRefSpecificationSupport(final YangParserConfiguration config,
+ final SubstatementValidator validator) {
+ super(config, validator);
+ }
+
+ static @NonNull IdentityRefSpecificationSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new IdentityRefSpecificationSupport(config, RFC6020_VALIDATOR);
+ }
+
+ static @NonNull IdentityRefSpecificationSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new IdentityRefSpecificationSupport(config, RFC7950_VALIDATOR);
}
@Override
- public final void onFullDefinitionDeclared(final Mutable<QName, IdentityRefSpecification,
+ public void onFullDefinitionDeclared(final Mutable<QName, IdentityRefSpecification,
EffectiveStatement<QName, IdentityRefSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
}
@Override
- protected final IdentityRefSpecification createDeclared(final StmtContext<QName, IdentityRefSpecification, ?> ctx,
+ protected IdentityRefSpecification createDeclared(final StmtContext<QName, IdentityRefSpecification, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
if (substatements.isEmpty()) {
throw noBase(ctx);
}
@Override
- protected final EffectiveStatement<QName, IdentityRefSpecification> createEffective(
+ protected EffectiveStatement<QName, IdentityRefSpecification> createEffective(
final Current<QName, IdentityRefSpecification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
if (substatements.isEmpty()) {
SubstatementValidator.builder(YangStmtMapping.TYPE).addOptional(YangStmtMapping.REQUIRE_INSTANCE).build();
InstanceIdentifierSpecificationSupport(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
+++ /dev/null
-/*
- * Copyright (c) 2017 Pantheon Technologies, s.r.o. 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.rfc7950.stmt.type;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-
-final class LeafrefSpecificationRFC6020Support extends AbstractLeafrefSpecificationSupport {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.TYPE).addMandatory(YangStmtMapping.PATH).build();
-
- LeafrefSpecificationRFC6020Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2017 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.rfc7950.stmt.type;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-
-/**
- * Class providing necessary support for processing YANG 1.1 leafref statement.
- */
-final class LeafrefSpecificationRFC7950Support extends AbstractLeafrefSpecificationSupport {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.TYPE)
- .addMandatory(YangStmtMapping.PATH)
- .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
- .build();
-
- LeafrefSpecificationRFC7950Support(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
-}
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-abstract class AbstractLeafrefSpecificationSupport extends AbstractTypeSupport<LeafrefSpecification> {
- AbstractLeafrefSpecificationSupport(final YangParserConfiguration config) {
- super(config);
+final class LeafrefSpecificationSupport extends AbstractTypeSupport<LeafrefSpecification> {
+ private static final SubstatementValidator RFC6020_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMandatory(YangStmtMapping.PATH).build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE)
+ .addMandatory(YangStmtMapping.PATH)
+ .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
+ .build();
+
+ private LeafrefSpecificationSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(config, validator);
+ }
+
+ static LeafrefSpecificationSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new LeafrefSpecificationSupport(config, RFC6020_VALIDATOR);
+ }
+
+ static LeafrefSpecificationSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new LeafrefSpecificationSupport(config, RFC7950_VALIDATOR);
}
@Override
- protected final LeafrefSpecification createDeclared(final StmtContext<QName, LeafrefSpecification, ?> ctx,
+ protected LeafrefSpecification createDeclared(final StmtContext<QName, LeafrefSpecification, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
if (substatements.isEmpty()) {
throw noPath(ctx);
}
@Override
- protected final LeafrefSpecification attachDeclarationReference(final LeafrefSpecification stmt,
+ protected LeafrefSpecification attachDeclarationReference(final LeafrefSpecification stmt,
final DeclarationReference reference) {
return new RefLeafrefSpecification(stmt, reference);
}
public TypeStatementRFC7950Support(final YangParserConfiguration config) {
super(config);
argumentSpecificSupports = ImmutableMap.of(
- TypeDefinitions.LEAFREF.getLocalName(), new LeafrefSpecificationRFC7950Support(config),
- TypeDefinitions.IDENTITYREF.getLocalName(), new IdentityRefSpecificationRFC7950Support(config));
+ TypeDefinitions.LEAFREF.getLocalName(), LeafrefSpecificationSupport.rfc7950Instance(config),
+ TypeDefinitions.IDENTITYREF.getLocalName(), IdentityRefSpecificationSupport.rfc7950Instance(config));
}
@Override
SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.TYPE).build();
UnionSpecificationSupport(final YangParserConfiguration config) {
- super(config);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ super(config, SUBSTATEMENT_VALIDATOR);
}
@Override
public final class UsesStatementSupport
extends AbstractQNameStatementSupport<UsesStatement, UsesEffectiveStatement> {
private static final Logger LOG = LoggerFactory.getLogger(UsesStatementSupport.class);
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .USES)
- .addAny(YangStmtMapping.AUGMENT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.REFINE)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.USES)
+ .addAny(YangStmtMapping.AUGMENT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.REFINE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
public UsesStatementSupport(final YangParserConfiguration config) {
- super(YangStmtMapping.USES, StatementPolicy.exactReplica(), config);
+ super(YangStmtMapping.USES, StatementPolicy.exactReplica(), config, SUBSTATEMENT_VALIDATOR);
}
@Override
});
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
@Override
protected UsesStatement createDeclared(final StmtContext<QName, UsesStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
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.SubstatementValidator;
public final class ThirdPartyExtensionSupport
extends AbstractStringStatementSupport<ThirdPartyExtensionStatement, ThirdPartyExtensionEffectiveStatement> {
public ThirdPartyExtensionSupport(final YangParserConfiguration config) {
- super(ThirdPartyExtensionsMapping.THIRD_PARTY_EXTENSION, StatementPolicy.contextIndependent(), config);
+ super(ThirdPartyExtensionsMapping.THIRD_PARTY_EXTENSION, StatementPolicy.contextIndependent(), config, null);
}
@Override
stmt.addToNs(ThirdPartyNamespace.class, Empty.getInstance(), "Third-party namespace test.");
}
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return null;
- }
-
@Override
protected ThirdPartyExtensionStatement createDeclared(
final StmtContext<String, ThirdPartyExtensionStatement, ?> ctx,
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
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;
protected AbstractBooleanStatementSupport(final StatementDefinition publicDefinition,
final E emptyEffectiveFalse, final E emptyEffectiveTrue, final StatementPolicy<Boolean, D> policy,
- final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final YangParserConfiguration config, final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
this.emptyEffectiveFalse = requireNonNull(emptyEffectiveFalse);
this.emptyEffectiveTrue = requireNonNull(emptyEffectiveTrue);
emptyDeclaredFalse = requireNonNull(emptyEffectiveFalse.getDeclared());
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
public abstract class AbstractEmptyStatementSupport<D extends DeclaredStatement<Empty>,
E extends EffectiveStatement<Empty, D>> extends AbstractStatementSupport<Empty, D, E> {
protected AbstractEmptyStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<Empty, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final StatementPolicy<Empty, D> policy, final YangParserConfiguration config,
+ final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
}
@Override
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
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;
});
protected AbstractInternedStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<A, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final StatementPolicy<A, D> policy, final YangParserConfiguration config,
+ final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
}
@Override
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.Nullable;
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;
public abstract class AbstractInternedStringStatementSupport<D extends DeclaredStatement<String>,
E extends EffectiveStatement<String, D>> extends AbstractInternedStatementSupport<String, D, E> {
protected AbstractInternedStringStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<String, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final StatementPolicy<String, D> policy, final YangParserConfiguration config,
+ final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
}
@Override
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public abstract class AbstractQNameStatementSupport<D extends DeclaredStatement<QName>,
E extends EffectiveStatement<QName, D>> extends AbstractStatementSupport<QName, D, E> {
protected AbstractQNameStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<QName, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final StatementPolicy<QName, D> policy, final YangParserConfiguration config,
+ final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
}
@Override
import com.google.common.annotations.Beta;
import java.util.Collection;
import java.util.Objects;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CopyableNode;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
StatementPolicy.copyDeclared(new SchemaTreeEquality<>());
protected AbstractSchemaTreeStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<QName, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final StatementPolicy<QName, D> policy, final YangParserConfiguration config,
+ final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
}
/**
@Beta
public abstract class AbstractStatementSupport<A, D extends DeclaredStatement<A>,
E extends EffectiveStatement<A, D>> extends StatementSupport<A, D, E> {
+ private final SubstatementValidator substatementValidator;
private final boolean retainDeclarationReference;
protected AbstractStatementSupport(final StatementDefinition publicDefinition, final StatementPolicy<A, D> policy,
- final YangParserConfiguration config) {
+ final YangParserConfiguration config, final @Nullable SubstatementValidator validator) {
super(publicDefinition, policy);
this.retainDeclarationReference = config.retainDeclarationReferences();
+ this.substatementValidator = validator;
+ }
+
+ @Override
+ protected final SubstatementValidator substatementValidator() {
+ return substatementValidator;
}
@Override
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.Nullable;
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;
public abstract class AbstractStringStatementSupport<D extends DeclaredStatement<String>,
E extends EffectiveStatement<String, D>> extends AbstractStatementSupport<String, D, E> {
protected AbstractStringStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<String, D> policy, final YangParserConfiguration config) {
- super(publicDefinition, policy, config);
+ final StatementPolicy<String, D> policy, final YangParserConfiguration config,
+ final @Nullable SubstatementValidator validator) {
+ super(publicDefinition, policy, config, validator);
}
@Override
}
@Override
- protected SubstatementValidator getSubstatementValidator() {
- return delegate.getSubstatementValidator();
+ protected SubstatementValidator substatementValidator() {
+ return delegate.substatementValidator();
}
@Override
*
* <p>
* Implementation may use method to perform actions on this event or register modification action using
- * {@link StmtContext.Mutable#newInferenceAction(ModelProcessingPhase)}.
+ * {@link Mutable#newInferenceAction(ModelProcessingPhase)}.
*
* @param stmt Context of added statement.
* @throws SourceException when an inconsistency is detected.
*
* <p>
* Implementation may use method to perform actions on this event or register modification action using
- * {@link StmtContext.Mutable#newInferenceAction(ModelProcessingPhase)}.
+ * {@link Mutable#newInferenceAction(ModelProcessingPhase)}.
*
* @param stmt Context of added statement. Argument and statement parent is accessible.
* @throws SourceException when an inconsistency is detected.
*
* <p>
* Implementation may use method to perform actions on this event or register modification action using
- * {@link StmtContext.Mutable#newInferenceAction(ModelProcessingPhase)}.
+ * {@link Mutable#newInferenceAction(ModelProcessingPhase)}.
*
* @param stmt Context of added statement. Argument and statement parent is accessible.
* @throws SourceException when an inconsistency is detected.
*/
- public void onFullDefinitionDeclared(final
StmtContext.Mutable<A, D, E> stmt) {
- final SubstatementValidator validator = getSubstatementValidator();
+ public void onFullDefinitionDeclared(final Mutable<A, D, E> stmt) {
+ final SubstatementValidator validator = substatementValidator();
if (validator != null) {
validator.validate(stmt);
}
*
* @return substatement validator or null, if substatement validator is not defined
*/
- // FIXME: rename to 'substatementValidator' and perhaps let it be passed in?
- protected abstract @Nullable SubstatementValidator getSubstatementValidator();
+ protected abstract @Nullable SubstatementValidator substatementValidator();
/**
* Returns true if this support has argument specific supports.
Code Review / yangtools.git / commitdiff