import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
E extends EffectiveStatement<QName, D>> extends AbstractStatementSupport<QName, D, E> {
private final SubstatementValidator validator;
- AbstractIdentityAwareStatementSupport(final StatementDefinition publicDefinition) {
- super(publicDefinition, StatementPolicy.exactReplica());
+ AbstractIdentityAwareStatementSupport(final StatementDefinition publicDefinition,
+ final YangParserConfiguration config) {
+ super(publicDefinition, StatementPolicy.exactReplica(), config);
validator = SubstatementValidator.builder(publicDefinition).build();
}
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public final class AugmentIdentifierStatementSupport
extends AbstractStatementSupport<UnqualifiedQName, AugmentIdentifierStatement,
AugmentIdentifierEffectiveStatement> {
- public static final @NonNull AugmentIdentifierStatementSupport INSTANCE = new AugmentIdentifierStatementSupport();
-
private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER).build();
- private AugmentIdentifierStatementSupport() {
- super(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER, StatementPolicy.contextIndependent());
+ public AugmentIdentifierStatementSupport(final YangParserConfiguration config) {
+ super(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER, StatementPolicy.contextIndependent(), config);
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.ContextInstanceEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.ContextInstanceStatement;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
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.stmt.IdentityEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@Beta
public final class ContextInstanceStatementSupport
extends AbstractIdentityAwareStatementSupport<ContextInstanceStatement, ContextInstanceEffectiveStatement> {
- public static final @NonNull ContextInstanceStatementSupport INSTANCE = new ContextInstanceStatementSupport();
-
- private ContextInstanceStatementSupport() {
- super(OpenDaylightExtensionsStatements.CONTEXT_INSTANCE);
+ public ContextInstanceStatementSupport(final YangParserConfiguration config) {
+ super(OpenDaylightExtensionsStatements.CONTEXT_INSTANCE, config);
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.ContextReferenceEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.ContextReferenceStatement;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
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.stmt.IdentityEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@Beta
public final class ContextReferenceStatementSupport
extends AbstractIdentityAwareStatementSupport<ContextReferenceStatement, ContextReferenceEffectiveStatement> {
- public static final @NonNull ContextReferenceStatementSupport INSTANCE = new ContextReferenceStatementSupport();
-
- private ContextReferenceStatementSupport() {
- super(OpenDaylightExtensionsStatements.CONTEXT_REFERENCE);
+ public ContextReferenceStatementSupport(final YangParserConfiguration config) {
+ super(OpenDaylightExtensionsStatements.CONTEXT_REFERENCE, config);
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.InstanceTargetEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.InstanceTargetStatement;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@Beta
public final class InstanceTargetStatementSupport
extends AbstractStringStatementSupport<InstanceTargetStatement, InstanceTargetEffectiveStatement> {
- public static final @NonNull InstanceTargetStatementSupport INSTANCE = new InstanceTargetStatementSupport();
-
private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(OpenDaylightExtensionsStatements.INSTANCE_TARGET).build();
- private InstanceTargetStatementSupport() {
- super(OpenDaylightExtensionsStatements.INSTANCE_TARGET, StatementPolicy.contextIndependent());
+ public InstanceTargetStatementSupport(final YangParserConfiguration config) {
+ super(OpenDaylightExtensionsStatements.INSTANCE_TARGET, StatementPolicy.contextIndependent(), config);
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
import org.opendaylight.yangtools.odlext.model.api.RpcContextReferenceEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.RpcContextReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@Beta
public final class RpcContextReferenceStatementSupport
extends AbstractStringStatementSupport<RpcContextReferenceStatement, RpcContextReferenceEffectiveStatement> {
- public static final @NonNull RpcContextReferenceStatementSupport INSTANCE =
- new RpcContextReferenceStatementSupport();
-
private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(OpenDaylightExtensionsStatements.RPC_CONTEXT_REFERENCE).build();
- private RpcContextReferenceStatementSupport() {
- super(OpenDaylightExtensionsStatements.RPC_CONTEXT_REFERENCE, StatementPolicy.contextIndependent());
+ public RpcContextReferenceStatementSupport(final YangParserConfiguration config) {
+ super(OpenDaylightExtensionsStatements.RPC_CONTEXT_REFERENCE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
@BeforeClass
public static void createReactor() {
reactor = RFC7950Reactors.vanillaReactorBuilder()
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ContextInstanceStatementSupport.INSTANCE)
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ContextReferenceStatementSupport.INSTANCE)
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new ContextInstanceStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new ContextReferenceStatementSupport(YangParserConfiguration.DEFAULT))
.build();
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
private final SubstatementValidator validator;
- AbstractHashedValueStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.contextIndependent());
+ AbstractHashedValueStatementSupport(final StatementDefinition definition, final YangParserConfiguration config) {
+ super(definition, StatementPolicy.contextIndependent(), config);
this.validator = SubstatementValidator.builder(definition).build();
}
package org.opendaylight.yangtools.openconfig.parser;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
public final class EncryptedValueStatementSupport extends AbstractHashedValueStatementSupport {
- private static final EncryptedValueStatementSupport INSTANCE = new EncryptedValueStatementSupport();
-
- private EncryptedValueStatementSupport() {
- super(OpenConfigStatements.OPENCONFIG_ENCRYPTED_VALUE);
- }
-
- public static EncryptedValueStatementSupport getInstance() {
- return INSTANCE;
+ public EncryptedValueStatementSupport(final YangParserConfiguration config) {
+ super(OpenConfigStatements.OPENCONFIG_ENCRYPTED_VALUE, config);
}
}
package org.opendaylight.yangtools.openconfig.parser;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
public final class HashedValueStatementSupport extends AbstractHashedValueStatementSupport {
- private static final HashedValueStatementSupport INSTANCE = new HashedValueStatementSupport();
-
- private HashedValueStatementSupport() {
- super(OpenConfigStatements.OPENCONFIG_HASHED_VALUE);
- }
-
- public static HashedValueStatementSupport getInstance() {
- return INSTANCE;
+ public HashedValueStatementSupport(final YangParserConfiguration config) {
+ super(OpenConfigStatements.OPENCONFIG_HASHED_VALUE, config);
}
}
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-spi</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-spi</artifactId>
<artifactId>yang-parser-rfc7950</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-api</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-repo-api</artifactId>
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
}
private static final Logger LOG = LoggerFactory.getLogger(GetFilterElementAttributesStatementSupport.class);
- private static final GetFilterElementAttributesStatementSupport INSTANCE =
- new GetFilterElementAttributesStatementSupport(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES);
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES).build();
- private final SubstatementValidator validator;
-
- GetFilterElementAttributesStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.reject());
- this.validator = SubstatementValidator.builder(definition).build();
- }
-
- public static GetFilterElementAttributesStatementSupport getInstance() {
- return INSTANCE;
+ public GetFilterElementAttributesStatementSupport(final YangParserConfiguration config) {
+ super(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES, StatementPolicy.reject(), config);
}
@Override
@Override
protected SubstatementValidator getSubstatementValidator() {
- return validator;
+ return VALIDATOR;
}
@Override
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
public static void createReactor() {
reactor = RFC7950Reactors.defaultReactorBuilder()
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- GetFilterElementAttributesStatementSupport.getInstance())
+ new GetFilterElementAttributesStatementSupport(YangParserConfiguration.DEFAULT))
.build();
}
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-spi</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-spi</artifactId>
<artifactId>yang-parser-rfc7950</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-api</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-reactor</artifactId>
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
}
}
- private static final DefaultDenyAllStatementSupport INSTANCE =
- new DefaultDenyAllStatementSupport(NACMStatements.DEFAULT_DENY_ALL);
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(NACMStatements.DEFAULT_DENY_ALL).build();
- private final SubstatementValidator validator;
-
- private DefaultDenyAllStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.contextIndependent());
- this.validator = SubstatementValidator.builder(definition).build();
- }
-
- public static DefaultDenyAllStatementSupport getInstance() {
- return INSTANCE;
+ public DefaultDenyAllStatementSupport(final YangParserConfiguration config) {
+ super(NACMStatements.DEFAULT_DENY_ALL, StatementPolicy.contextIndependent(), config);
}
@Override
protected SubstatementValidator getSubstatementValidator() {
- return validator;
+ return VALIDATOR;
}
@Override
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
}
}
- private static final DefaultDenyWriteStatementSupport INSTANCE =
- new DefaultDenyWriteStatementSupport(NACMStatements.DEFAULT_DENY_WRITE);
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(NACMStatements.DEFAULT_DENY_WRITE).build();
- private final SubstatementValidator validator;
-
- DefaultDenyWriteStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.contextIndependent());
- this.validator = SubstatementValidator.builder(definition).build();
- }
-
- public static DefaultDenyWriteStatementSupport getInstance() {
- return INSTANCE;
+ public DefaultDenyWriteStatementSupport(final YangParserConfiguration config) {
+ super(NACMStatements.DEFAULT_DENY_WRITE, StatementPolicy.contextIndependent(), config);
}
@Override
protected SubstatementValidator getSubstatementValidator() {
- return validator;
+ return VALIDATOR;
}
@Override
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
public static void createReactor() {
reactor = RFC7950Reactors.defaultReactorBuilder()
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- DefaultDenyAllStatementSupport.getInstance())
+ new DefaultDenyAllStatementSupport(YangParserConfiguration.DEFAULT))
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- DefaultDenyWriteStatementSupport.getInstance())
+ new DefaultDenyWriteStatementSupport(YangParserConfiguration.DEFAULT))
.build();
}
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-spi</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-spi</artifactId>
<artifactId>yang-parser-rfc7950</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-api</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-reactor</artifactId>
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
.add(YangStmtMapping.STATUS, 0, 1)
.add(IetfYangSmiv2ExtensionsMapping.OBJECT_ID, 0, 1)
.build();
- private static final AliasStatementSupport INSTANCE = new AliasStatementSupport();
- private AliasStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.ALIAS, StatementPolicy.contextIndependent());
- }
-
- public static AliasStatementSupport getInstance() {
- return INSTANCE;
+ public AliasStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.ALIAS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
extends AbstractStringStatementSupport<DefValStatement, DefValEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.DEFVAL).build();
- private static final DefValStatementSupport INSTANCE = new DefValStatementSupport();
- private DefValStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.DEFVAL, StatementPolicy.contextIndependent());
- }
-
- public static DefValStatementSupport getInstance() {
- return INSTANCE;
+ public DefValStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.DEFVAL, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
extends AbstractStringStatementSupport<DisplayHintStatement, DisplayHintEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT).build();
- private static final DisplayHintStatementSupport INSTANCE = new DisplayHintStatementSupport();
- private DisplayHintStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT, StatementPolicy.contextIndependent());
- }
-
- public static DisplayHintStatementSupport getInstance() {
- return INSTANCE;
+ public DisplayHintStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.rfc6643.model.api.ImpliedStatement;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
extends AbstractStringStatementSupport<ImpliedStatement, ImpliedEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.IMPLIED).build();
- private static final ImpliedStatementSupport INSTANCE = new ImpliedStatementSupport();
- private ImpliedStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.IMPLIED, StatementPolicy.contextIndependent());
- }
-
- public static ImpliedStatementSupport getInstance() {
- return INSTANCE;
+ public ImpliedStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.IMPLIED, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
extends AbstractStatementSupport<MaxAccess, MaxAccessStatement, MaxAccessEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS).build();
- private static final MaxAccessStatementSupport INSTANCE = new MaxAccessStatementSupport();
- private MaxAccessStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS, StatementPolicy.contextIndependent());
- }
-
- public static MaxAccessStatementSupport getInstance() {
- return INSTANCE;
+ public MaxAccessStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.rfc6643.model.api.OidStatement;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
extends AbstractStatementSupport<ObjectIdentifier, OidStatement, OidEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.OBJECT_ID).build();
- private static final OidStatementSupport INSTANCE = new OidStatementSupport();
- private OidStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.OBJECT_ID, StatementPolicy.contextIndependent());
- }
-
- public static OidStatementSupport getInstance() {
- return INSTANCE;
+ public OidStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.OBJECT_ID, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
extends AbstractStatementSupport<Uint32, SubIdStatement, SubIdEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.SUB_ID).build();
- private static final SubIdStatementSupport INSTANCE = new SubIdStatementSupport();
- private SubIdStatementSupport() {
- super(IetfYangSmiv2ExtensionsMapping.SUB_ID, StatementPolicy.contextIndependent());
- }
-
- public static SubIdStatementSupport getInstance() {
- return INSTANCE;
+ public SubIdStatementSupport(final YangParserConfiguration config) {
+ super(IetfYangSmiv2ExtensionsMapping.SUB_ID, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
@BeforeClass
public static void createReactor() {
reactor = RFC7950Reactors.defaultReactorBuilder()
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DisplayHintStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MaxAccessStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DefValStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ImpliedStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AliasStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, OidStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, SubIdStatementSupport.getInstance())
- .build();
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new DisplayHintStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new MaxAccessStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new DefValStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new ImpliedStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new AliasStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new OidStatementSupport(YangParserConfiguration.DEFAULT))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new SubIdStatementSupport(YangParserConfiguration.DEFAULT))
+ .build();
}
@AfterClass
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypeBuilder;
import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypes;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements;
}
}
- private static final AnnotationStatementSupport INSTANCE = new AnnotationStatementSupport(
- MetadataStatements.ANNOTATION);
-
- private final SubstatementValidator validator;
-
- AnnotationStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.reject());
- this.validator = SubstatementValidator.builder(definition)
- .addMandatory(YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.UNITS)
- .build();
- }
-
- public static AnnotationStatementSupport getInstance() {
- return INSTANCE;
+ private static final SubstatementValidator VALIDATOR = SubstatementValidator.builder(MetadataStatements.ANNOTATION)
+ .addMandatory(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.UNITS)
+ .build();
+
+ public AnnotationStatementSupport(final YangParserConfiguration config) {
+ super(MetadataStatements.ANNOTATION, StatementPolicy.reject(), config);
}
@Override
@Override
protected SubstatementValidator getSubstatementValidator() {
- return validator;
+ return VALIDATOR;
}
@Override
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
@BeforeClass
public static void createReactor() {
reactor = RFC7950Reactors.vanillaReactorBuilder()
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AnnotationStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new AnnotationStatementSupport(YangParserConfiguration.DEFAULT))
.build();
}
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithRawStringArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
}
}
- private static final YangDataStatementSupport INSTANCE = new YangDataStatementSupport(YangDataStatements.YANG_DATA);
-
private final SubstatementValidator declaredValidator;
- private YangDataStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.reject());
- declaredValidator = SubstatementValidator.builder(definition)
+ 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();
}
- public static YangDataStatementSupport getInstance() {
- return INSTANCE;
- }
-
@Override
public void onStatementAdded(final Mutable<String, YangDataStatement, YangDataEffectiveStatement> ctx) {
// as per https://tools.ietf.org/html/rfc8040#section-8,
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
public static void createReactor() {
reactor = RFC7950Reactors.vanillaReactorBuilder()
.addNamespaceSupport(ModelProcessingPhase.FULL_DECLARATION, YangDataArgumentNamespace.BEHAVIOUR)
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, YangDataStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new YangDataStatementSupport(YangParserConfiguration.DEFAULT))
.build();
}
--- /dev/null
+/*
+ * Copyright (c) 2021 PANTHEON.tech, 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.rfc8528.parser;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yangtools.rfc8528.model.api.MountPointStatement;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements;
+
+final class MountPointStatementImpl extends WithSubstatements implements MountPointStatement {
+ MountPointStatementImpl(final QName argument, final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ super(argument, substatements);
+ }
+}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
public final class MountPointStatementSupport
extends AbstractQNameStatementSupport<MountPointStatement, MountPointEffectiveStatement> {
+ private static final SubstatementValidator VALIDATOR =
+ SubstatementValidator.builder(SchemaMountStatements.MOUNT_POINT)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .build();
- private static final class Declared extends WithSubstatements implements MountPointStatement {
- Declared(final QName argument, final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- super(argument, substatements);
- }
- }
-
- private static final MountPointStatementSupport INSTANCE = new MountPointStatementSupport(
- SchemaMountStatements.MOUNT_POINT);
-
- private final SubstatementValidator validator;
-
- MountPointStatementSupport(final StatementDefinition definition) {
- super(definition, StatementPolicy.copyDeclared((copy, current, substatements) ->
+ public MountPointStatementSupport(final YangParserConfiguration config) {
+ super(SchemaMountStatements.MOUNT_POINT, StatementPolicy.copyDeclared((copy, current, substatements) ->
copy.getArgument().equals(current.getArgument())
// Implied by UnknownSchemaNode
&& copy.history().isAugmenting() == current.history().isAugmenting()
&& copy.history().isAddedByUses() == current.history().isAddedByUses()
- && copy.equalParentPath(current)));
- this.validator = SubstatementValidator.builder(definition)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .build();
- }
-
- public static MountPointStatementSupport getInstance() {
- return INSTANCE;
+ && copy.equalParentPath(current)), config);
}
// FIXME: these two methods are not quite right. RFC8528 states that:
@Override
protected SubstatementValidator getSubstatementValidator() {
- return validator;
+ return VALIDATOR;
}
@Override
protected MountPointStatement createDeclared(@NonNull final StmtContext<QName, MountPointStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- return new Declared(ctx.getArgument(), substatements);
+ return new MountPointStatementImpl(ctx.getArgument(), substatements);
}
@Override
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
@BeforeClass
public static void createReactor() {
reactor = RFC7950Reactors.vanillaReactorBuilder()
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MountPointStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new MountPointStatementSupport(YangParserConfiguration.DEFAULT))
.build();
}
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import com.google.common.base.MoreObjects;
+import java.util.Objects;
import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
@Beta
@NonNullByDefault
public final class YangParserConfiguration implements Immutable {
- public static final YangParserConfiguration DEFAULT = new YangParserConfiguration(StatementParserMode.DEFAULT_MODE);
+ /**
+ * System-wide default configuration.
+ */
+ public static final YangParserConfiguration DEFAULT = builder().build();
private final StatementParserMode parserMode;
+ private final boolean retainDeclarationReferences;
- private YangParserConfiguration(final StatementParserMode parserMode) {
+ private YangParserConfiguration(final StatementParserMode parserMode, final boolean retainDeclarationReferences) {
this.parserMode = requireNonNull(parserMode);
+ this.retainDeclarationReferences = retainDeclarationReferences;
}
public StatementParserMode parserMode() {
return parserMode;
}
+ public boolean retainDeclarationReferences() {
+ return retainDeclarationReferences;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(parserMode, retainDeclarationReferences);
+ }
+
+ @Override
+ public boolean equals(final @Nullable Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof YangParserConfiguration)) {
+ return false;
+ }
+ final YangParserConfiguration other = (YangParserConfiguration) obj;
+ return parserMode == other.parserMode && retainDeclarationReferences == other.retainDeclarationReferences;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this)
+ .add("parserMode", parserMode)
+ .add("retainDeclarationReferences", retainDeclarationReferences)
+ .toString();
+ }
+
public static Builder builder() {
return new Builder();
}
public static final class Builder implements org.opendaylight.yangtools.concepts.Builder<YangParserConfiguration> {
private StatementParserMode parserMode = StatementParserMode.DEFAULT_MODE;
+ private boolean retainDeclarationReferences = false;
private Builder() {
// Hidden on purpose
@Override
public YangParserConfiguration build() {
- return new YangParserConfiguration(parserMode);
+ return new YangParserConfiguration(parserMode, retainDeclarationReferences);
+ }
+
+ public Builder parserMode(final StatementParserMode newParserMode) {
+ this.parserMode = requireNonNull(newParserMode);
+ return this;
}
- public Builder setParserMode(final StatementParserMode parserMode) {
- this.parserMode = requireNonNull(parserMode);
+ public Builder retainDeclarationReferences(final boolean newRetainDeclarationReferences) {
+ this.retainDeclarationReferences = newRetainDeclarationReferences;
return this;
}
}
*/
@Deprecated(forRemoval = true)
default @NonNull YangParser createParser(final StatementParserMode parserMode) {
- return createParser(YangParserConfiguration.builder().setParserMode(parserMode).build());
+ return createParser(YangParserConfiguration.builder().parserMode(parserMode).build());
}
}
import org.opendaylight.yangtools.rfc8040.parser.YangDataArgumentNamespace;
import org.opendaylight.yangtools.rfc8040.parser.YangDataStatementSupport;
import org.opendaylight.yangtools.rfc8528.parser.MountPointStatementSupport;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.CustomCrossSourceStatementReactorBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
* @return A populated CrossSourceStatementReactor builder.
*/
public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder() {
- return addExtensions(RFC7950Reactors.defaultReactorBuilder());
+ return defaultReactorBuilder(YangParserConfiguration.DEFAULT);
+ }
+
+ /**
+ * Return a baseline CrossSourceStatementReactor {@link Builder}. The builder is initialized to the equivalent
+ * of the reactor returned via {@link #defaultReactor()}, but can be further customized before use.
+ *
+ * @param config parser configuration
+ * @return A populated CrossSourceStatementReactor builder.
+ */
+ public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder(
+ final YangParserConfiguration config) {
+ return addExtensions(RFC7950Reactors.defaultReactorBuilder(config), config);
}
/**
*/
public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder(
final YangXPathParserFactory xpathFactory) {
- return addExtensions(RFC7950Reactors.defaultReactorBuilder(xpathFactory));
+ return defaultReactorBuilder(xpathFactory, YangParserConfiguration.DEFAULT);
+ }
+
+ /**
+ * Return a baseline CrossSourceStatementReactor {@link Builder}. The builder is initialized to the equivalent
+ * of the reactor returned via {@link #defaultReactor()}, but can be further customized before use.
+ *
+ * @param config parser configuration
+ * @return A populated CrossSourceStatementReactor builder.
+ */
+ public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder(
+ final YangXPathParserFactory xpathFactory, final YangParserConfiguration config) {
+ return addExtensions(RFC7950Reactors.defaultReactorBuilder(xpathFactory, config), config);
}
private static @NonNull CustomCrossSourceStatementReactorBuilder addExtensions(
- final @NonNull CustomCrossSourceStatementReactorBuilder builder) {
+ final @NonNull CustomCrossSourceStatementReactorBuilder builder, final YangParserConfiguration config) {
return builder
// OpenDaylight extensions
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AugmentIdentifierStatementSupport.INSTANCE)
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ContextInstanceStatementSupport.INSTANCE)
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ContextReferenceStatementSupport.INSTANCE)
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, InstanceTargetStatementSupport.INSTANCE)
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- RpcContextReferenceStatementSupport.INSTANCE)
+ new AugmentIdentifierStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new ContextInstanceStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new ContextReferenceStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new InstanceTargetStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new RpcContextReferenceStatementSupport(config))
// RFC6241 get-filter-element-attributes support
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- GetFilterElementAttributesStatementSupport.getInstance())
+ new GetFilterElementAttributesStatementSupport(config))
// RFC6536 default-deny-{all,write} support
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- DefaultDenyAllStatementSupport.getInstance())
+ new DefaultDenyAllStatementSupport(config))
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- DefaultDenyWriteStatementSupport.getInstance())
+ new DefaultDenyWriteStatementSupport(config))
// RFC6643 extensions
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DisplayHintStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MaxAccessStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DefValStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ImpliedStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AliasStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, OidStatementSupport.getInstance())
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, SubIdStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new DisplayHintStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new MaxAccessStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new DefValStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new ImpliedStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new AliasStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new OidStatementSupport(config))
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new SubIdStatementSupport(config))
// RFC7952 annotation support
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AnnotationStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new AnnotationStatementSupport(config))
// RFC8040 yang-data support
.addNamespaceSupport(ModelProcessingPhase.FULL_DECLARATION, YangDataArgumentNamespace.BEHAVIOUR)
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, YangDataStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new YangDataStatementSupport(config))
// RFC8528 yang-data support
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MountPointStatementSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, new MountPointStatementSupport(config))
// OpenConfig extensions support (except openconfig-version)
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- EncryptedValueStatementSupport.getInstance())
+ new EncryptedValueStatementSupport(config))
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
- HashedValueStatementSupport.getInstance());
+ new HashedValueStatementSupport(config));
}
}
package org.opendaylight.yangtools.yang.parser.impl;
import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import java.util.Collection;
import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.Function;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
@Component(immediate = true)
public final class YangParserFactoryImpl implements YangParserFactory {
private static final List<StatementParserMode> SUPPORTED_MODES = List.of(
- StatementParserMode.DEFAULT_MODE,
- StatementParserMode.SEMVER_MODE);
+ StatementParserMode.DEFAULT_MODE, StatementParserMode.SEMVER_MODE);
- private final CrossSourceStatementReactor reactor;
-
- private YangParserFactoryImpl(final @NonNull CrossSourceStatementReactor reactor) {
- this.reactor = requireNonNull(reactor);
- }
+ private final ConcurrentMap<YangParserConfiguration, CrossSourceStatementReactor> reactors =
+ new ConcurrentHashMap<>(2);
+ private final Function<YangParserConfiguration, CrossSourceStatementReactor> reactorFactory;
/**
* Construct a new {@link YangParserFactory} backed by {@link DefaultReactors#defaultReactor()}.
*/
public YangParserFactoryImpl() {
- this(DefaultReactors.defaultReactor());
+ reactorFactory = config -> DefaultReactors.defaultReactorBuilder(config).build();
+ // Make sure default reactor is available
+ reactorFactory.apply(YangParserConfiguration.DEFAULT);
}
@Inject
@Activate
public YangParserFactoryImpl(final @Reference YangXPathParserFactory xpathFactory) {
- this(DefaultReactors.defaultReactorBuilder(xpathFactory).build());
- }
-
- /**
- * Construct a new {@link YangParserFactory} backed by specified reactor.
- *
- * @param reactor Backing reactor
- * @return A new YangParserFactory
- */
- public static @NonNull YangParserFactory forReactor(final @NonNull CrossSourceStatementReactor reactor) {
- return new YangParserFactoryImpl(reactor);
+ reactorFactory = config -> DefaultReactors.defaultReactorBuilder(xpathFactory, config).build();
}
@Override
public @NonNull YangParser createParser(final YangParserConfiguration configuration) {
final StatementParserMode mode = configuration.parserMode();
checkArgument(SUPPORTED_MODES.contains(mode), "Unsupported parser mode %s", mode);
+
+ final CrossSourceStatementReactor reactor = reactors.computeIfAbsent(configuration, reactorFactory);
return new YangParserImpl(reactor.newBuild(mode));
}
}
private final ImmutableMap<ModelProcessingPhase, StatementSupportBundle> supports;
private final Set<SourceSpecificContext> sources = new HashSet<>();
private final ImmutableSet<YangVersion> supportedVersions;
+
+ // FIXME: 7.0.0: this flag should really be passed to {Import,Module}StatementSupport's bootstrap to wire the
+ // appropriate behaviour. That requires a change in StatementSupport lifecycle, as statement supports
+ // would no longer be stateless singletons.
private final boolean enabledSemanticVersions;
private Set<SourceSpecificContext> libSources = new HashSet<>();
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionStatement;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
public final class OpenConfigVersionSupport
extends AbstractStatementSupport<SemVer, OpenConfigVersionStatement, OpenConfigVersionEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- OpenConfigStatements.OPENCONFIG_VERSION).build();
- private static final OpenConfigVersionSupport INSTANCE = new OpenConfigVersionSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(OpenConfigStatements.OPENCONFIG_VERSION).build();
- private OpenConfigVersionSupport() {
- super(OpenConfigStatements.OPENCONFIG_VERSION, StatementPolicy.reject());
- }
-
- public static OpenConfigVersionSupport getInstance() {
- return INSTANCE;
+ public OpenConfigVersionSupport(final YangParserConfiguration config) {
+ super(OpenConfigStatements.OPENCONFIG_VERSION, StatementPolicy.reject(), config);
}
@Override
import com.google.common.collect.Sets;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.openconfig.stmt.OpenConfigVersionSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ModuleQNameToPrefix;
import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.YangNamespaceContextNamespace;
private static final ImmutableSet<YangVersion> SUPPORTED_VERSIONS = Sets.immutableEnumSet(VERSION_1, VERSION_1_1);
private static final StatementSupportBundle INIT_BUNDLE = StatementSupportBundle.builder(SUPPORTED_VERSIONS)
- .addSupport(ValidationBundlesNamespace.BEHAVIOUR)
- .addSupport(SupportedFeaturesNamespace.BEHAVIOUR)
- .addSupport(ModulesDeviatedByModules.BEHAVIOUR)
- .build();
+ .addSupport(ValidationBundlesNamespace.BEHAVIOUR)
+ .addSupport(SupportedFeaturesNamespace.BEHAVIOUR)
+ .addSupport(ModulesDeviatedByModules.BEHAVIOUR)
+ .build();
- private static final StatementSupportBundle PRE_LINKAGE_BUNDLE = StatementSupportBundle.derivedFrom(INIT_BUNDLE)
- .addVersionSpecificSupport(VERSION_1, ModuleStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, ModuleStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, SubmoduleStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, SubmoduleStatementSupport.rfc7950Instance())
- .addSupport(NamespaceStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, ImportStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, ImportStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, IncludeStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, IncludeStatementSupport.rfc7950Instance())
- .addSupport(BelongsToStatementSupport.getInstance())
- .addSupport(PrefixStatementSupport.getInstance())
- .addSupport(YangVersionStatementSupport.getInstance())
- .addSupport(RevisionStatementSupport.getInstance())
- .addSupport(RevisionDateStatementSupport.getInstance())
+ private RFC7950Reactors() {
+ // Hidden on purpose
+ }
+
+ private static StatementSupportBundle preLinkageBundle(final YangParserConfiguration config) {
+ return StatementSupportBundle.derivedFrom(INIT_BUNDLE)
+ .addVersionSpecificSupport(VERSION_1, ModuleStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, ModuleStatementSupport.rfc7950Instance(config))
+ .addVersionSpecificSupport(VERSION_1, SubmoduleStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, SubmoduleStatementSupport.rfc7950Instance(config))
+ .addSupport(new NamespaceStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1, ImportStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, ImportStatementSupport.rfc7950Instance(config))
+ .addVersionSpecificSupport(VERSION_1, IncludeStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, IncludeStatementSupport.rfc7950Instance(config))
+ .addSupport(new BelongsToStatementSupport(config))
+ .addSupport(new PrefixStatementSupport(config))
+ .addSupport(new YangVersionStatementSupport(config))
+ .addSupport(new RevisionStatementSupport(config))
+ .addSupport(new RevisionDateStatementSupport(config))
.addSupport(ModuleNameToNamespace.BEHAVIOUR)
.addSupport(PreLinkageModuleNamespace.BEHAVIOUR)
.addSupport(ImpPrefixToNamespace.BEHAVIOUR)
.addSupport(QNameModuleNamespace.BEHAVIOUR)
.addSupport(ImportedVersionNamespace.BEHAVIOUR)
.build();
+ }
- private static final StatementSupportBundle LINKAGE_BUNDLE = StatementSupportBundle
- .derivedFrom(PRE_LINKAGE_BUNDLE)
- .addSupport(DescriptionStatementSupport.getInstance())
- .addSupport(ReferenceStatementSupport.getInstance())
- .addSupport(ContactStatementSupport.getInstance())
- .addSupport(OrganizationStatementSupport.getInstance())
+ private static StatementSupportBundle linkageBundle(final StatementSupportBundle preLinkageBundle,
+ final YangParserConfiguration config) {
+ return StatementSupportBundle.derivedFrom(preLinkageBundle)
+ .addSupport(new DescriptionStatementSupport(config))
+ .addSupport(new ReferenceStatementSupport(config))
+ .addSupport(new ContactStatementSupport(config))
+ .addSupport(new OrganizationStatementSupport(config))
.addSupport(ModuleNamespace.BEHAVIOUR)
.addSupport(ModuleNamespaceForBelongsTo.BEHAVIOUR)
.addSupport(SubmoduleNamespace.BEHAVIOUR)
.addSupport(BelongsToModuleContext.BEHAVIOUR)
.addSupport(BelongsToPrefixToModuleName.BEHAVIOUR)
.build();
+ }
- private static final StatementSupportBundle STMT_DEF_BUNDLE = StatementSupportBundle
- .derivedFrom(LINKAGE_BUNDLE)
- .addSupport(YinElementStatementSupport.getInstance())
- .addSupport(ArgumentStatementSupport.getInstance())
- .addSupport(ExtensionStatementSupport.getInstance())
+ private static StatementSupportBundle stmtDefBundle(final StatementSupportBundle linkageBundle,
+ final YangParserConfiguration config) {
+ final InputStatementSupport rfc6020input = InputStatementSupport.rfc6020Instance(config);
+ final InputStatementSupport rfc7950input = InputStatementSupport.rfc7950Instance(config);
+ final OutputStatementSupport rfc6020output = OutputStatementSupport.rfc6020Instance(config);
+ final OutputStatementSupport rfc7950output = OutputStatementSupport.rfc7950Instance(config);
+
+ return StatementSupportBundle.derivedFrom(linkageBundle)
+ .addSupport(new YinElementStatementSupport(config))
+ .addSupport(new ArgumentStatementSupport(config))
+ .addSupport(new ExtensionStatementSupport(config))
.addSupport(SchemaTreeNamespace.getInstance())
.addSupport(ExtensionNamespace.BEHAVIOUR)
- .addSupport(TypedefStatementSupport.getInstance())
+ .addSupport(new TypedefStatementSupport(config))
.addSupport(TypeNamespace.BEHAVIOUR)
- .addVersionSpecificSupport(VERSION_1, IdentityStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, IdentityStatementSupport.rfc7950Instance())
+ .addVersionSpecificSupport(VERSION_1, IdentityStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, IdentityStatementSupport.rfc7950Instance(config))
.addSupport(IdentityNamespace.BEHAVIOUR)
- .addSupport(DefaultStatementSupport.getInstance())
- .addSupport(StatusStatementSupport.getInstance())
+ .addSupport(new DefaultStatementSupport(config))
+ .addSupport(new StatusStatementSupport(config))
.addSupport(BaseTypeNamespace.BEHAVIOUR)
- .addVersionSpecificSupport(VERSION_1, TypeStatementRFC6020Support.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, TypeStatementRFC7950Support.getInstance())
- .addSupport(UnitsStatementSupport.getInstance())
- .addSupport(RequireInstanceStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, BitStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, BitStatementSupport.rfc7950Instance())
- .addSupport(PathStatementSupport.strictInstance())
- .addVersionSpecificSupport(VERSION_1, EnumStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, EnumStatementSupport.rfc7950Instance())
- .addSupport(LengthStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, PatternStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, PatternStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1_1, ModifierStatementSupport.getInstance())
- .addSupport(RangeStatementSupport.getInstance())
- .addSupport(KeyStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, ContainerStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, ContainerStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, GroupingStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, GroupingStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, ListStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, ListStatementSupport.rfc7950Instance())
+ .addVersionSpecificSupport(VERSION_1, new TypeStatementRFC6020Support(config))
+ .addVersionSpecificSupport(VERSION_1_1, new TypeStatementRFC7950Support(config))
+ .addSupport(new UnitsStatementSupport(config))
+ .addSupport(new RequireInstanceStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1, BitStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, BitStatementSupport.rfc7950Instance(config))
+ .addSupport(PathStatementSupport.strictInstance(config))
+ .addVersionSpecificSupport(VERSION_1, EnumStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, EnumStatementSupport.rfc7950Instance(config))
+ .addSupport(new LengthStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1, PatternStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, PatternStatementSupport.rfc7950Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, new ModifierStatementSupport(config))
+ .addSupport(new RangeStatementSupport(config))
+ .addSupport(new KeyStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1, ContainerStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, ContainerStatementSupport.rfc7950Instance(config))
+ .addVersionSpecificSupport(VERSION_1, GroupingStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, GroupingStatementSupport.rfc7950Instance(config))
+ .addVersionSpecificSupport(VERSION_1, ListStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, ListStatementSupport.rfc7950Instance(config))
.addSupport(ConfigListWarningNamespace.BEHAVIOUR)
- .addSupport(UniqueStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, ActionStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, RpcStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, RpcStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, InputStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, InputStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, OutputStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, OutputStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, NotificationStatementRFC6020Support.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, NotificationStatementRFC7950Support.getInstance())
- .addSupport(FractionDigitsStatementSupport.getInstance())
- .addSupport(BaseStatementSupport.getInstance())
+ .addSupport(new UniqueStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1_1, new ActionStatementSupport(config, rfc7950input, rfc7950output))
+ .addVersionSpecificSupport(VERSION_1, new RpcStatementSupport(config, rfc6020input, rfc6020output))
+ .addVersionSpecificSupport(VERSION_1_1, new RpcStatementSupport(config, rfc7950input, rfc7950output))
+ .addVersionSpecificSupport(VERSION_1, rfc6020input)
+ .addVersionSpecificSupport(VERSION_1_1, rfc7950input)
+ .addVersionSpecificSupport(VERSION_1, rfc6020output)
+ .addVersionSpecificSupport(VERSION_1_1, rfc7950output)
+ .addVersionSpecificSupport(VERSION_1, new NotificationStatementRFC6020Support(config))
+ .addVersionSpecificSupport(VERSION_1_1, new NotificationStatementRFC7950Support(config))
+ .addSupport(new FractionDigitsStatementSupport(config))
+ .addSupport(new BaseStatementSupport(config))
.addSupport(StatementDefinitionNamespace.BEHAVIOUR)
.build();
-
-
- private RFC7950Reactors() {
- // Hidden on purpose
}
/**
* @return A new {@link CustomCrossSourceStatementReactorBuilder}.
*/
public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder() {
- return addExtensions(vanillaReactorBuilder());
+ return defaultReactorBuilder(YangParserConfiguration.DEFAULT);
+ }
+
+ public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder(
+ final YangParserConfiguration config) {
+ return addExtensions(vanillaReactorBuilder(config), config);
}
public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder(
final YangXPathParserFactory xpathFactory) {
- return addExtensions(vanillaReactorBuilder(xpathFactory));
+ return defaultReactorBuilder(xpathFactory, YangParserConfiguration.DEFAULT);
+ }
+
+ public static @NonNull CustomCrossSourceStatementReactorBuilder defaultReactorBuilder(
+ final YangXPathParserFactory xpathFactory, final YangParserConfiguration config) {
+ return addExtensions(vanillaReactorBuilder(xpathFactory, config), config);
}
private static @NonNull CustomCrossSourceStatementReactorBuilder addExtensions(
- final @NonNull CustomCrossSourceStatementReactorBuilder builder) {
+ final @NonNull CustomCrossSourceStatementReactorBuilder builder, final YangParserConfiguration config) {
return builder
// Semantic version support
- .addStatementSupport(ModelProcessingPhase.SOURCE_LINKAGE, OpenConfigVersionSupport.getInstance())
+ .addStatementSupport(ModelProcessingPhase.SOURCE_LINKAGE, new OpenConfigVersionSupport(config))
.addNamespaceSupport(ModelProcessingPhase.SOURCE_LINKAGE, SemanticVersionNamespace.BEHAVIOUR)
.addNamespaceSupport(ModelProcessingPhase.SOURCE_LINKAGE, SemanticVersionModuleNamespace.BEHAVIOUR)
.addNamespaceSupport(ModelProcessingPhase.SOURCE_LINKAGE,
* @return A new {@link CustomCrossSourceStatementReactorBuilder}.
*/
public static @NonNull CustomCrossSourceStatementReactorBuilder vanillaReactorBuilder() {
- return vanillaReactorBuilder(ServiceLoaderState.XPath.INSTANCE);
+ return vanillaReactorBuilder(YangParserConfiguration.DEFAULT);
+ }
+
+ public static @NonNull CustomCrossSourceStatementReactorBuilder vanillaReactorBuilder(
+ final YangParserConfiguration config) {
+ return vanillaReactorBuilder(ServiceLoaderState.XPath.INSTANCE, config);
}
public static @NonNull CustomCrossSourceStatementReactorBuilder vanillaReactorBuilder(
final @NonNull YangXPathParserFactory xpathFactory) {
- return vanillaReactorBuilder(new XPathSupport(xpathFactory));
+ return vanillaReactorBuilder(xpathFactory, YangParserConfiguration.DEFAULT);
+ }
+
+ public static @NonNull CustomCrossSourceStatementReactorBuilder vanillaReactorBuilder(
+ final @NonNull YangXPathParserFactory xpathFactory, final YangParserConfiguration config) {
+ return vanillaReactorBuilder(new XPathSupport(xpathFactory), config);
}
private static @NonNull CustomCrossSourceStatementReactorBuilder vanillaReactorBuilder(
- final @NonNull XPathSupport xpathSupport) {
- final StatementSupportBundle fullDeclarationBundle = fullDeclarationBundle(xpathSupport);
+ final @NonNull XPathSupport xpathSupport, final YangParserConfiguration config) {
+ final StatementSupportBundle preLinkageBundle = preLinkageBundle(config);
+ final StatementSupportBundle linkageBundle = linkageBundle(preLinkageBundle, config);
+ final StatementSupportBundle stmtDefBundle = stmtDefBundle(linkageBundle, config);
+ final StatementSupportBundle fullDeclarationBundle =
+ fullDeclarationBundle(stmtDefBundle, xpathSupport, config);
+
return new CustomCrossSourceStatementReactorBuilder(SUPPORTED_VERSIONS)
.addAllSupports(ModelProcessingPhase.INIT, INIT_BUNDLE)
- .addAllSupports(ModelProcessingPhase.SOURCE_PRE_LINKAGE, PRE_LINKAGE_BUNDLE)
- .addAllSupports(ModelProcessingPhase.SOURCE_LINKAGE, LINKAGE_BUNDLE)
- .addAllSupports(ModelProcessingPhase.STATEMENT_DEFINITION, STMT_DEF_BUNDLE)
+ .addAllSupports(ModelProcessingPhase.SOURCE_PRE_LINKAGE, preLinkageBundle)
+ .addAllSupports(ModelProcessingPhase.SOURCE_LINKAGE, linkageBundle)
+ .addAllSupports(ModelProcessingPhase.STATEMENT_DEFINITION, stmtDefBundle)
.addAllSupports(ModelProcessingPhase.FULL_DECLARATION, fullDeclarationBundle)
.addAllSupports(ModelProcessingPhase.EFFECTIVE_MODEL, fullDeclarationBundle)
.addValidationBundle(ValidationBundleType.SUPPORTED_REFINE_SUBSTATEMENTS,
YangValidationBundles.SUPPORTED_DATA_NODES);
}
- private static @NonNull StatementSupportBundle fullDeclarationBundle(final XPathSupport xpathSupport) {
- return StatementSupportBundle
- .derivedFrom(STMT_DEF_BUNDLE)
- .addSupport(LeafStatementSupport.getInstance())
- .addSupport(ConfigStatementSupport.getInstance())
- .addSupport(DeviationStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, DeviateStatementRFC6020Support.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, DeviateStatementRFC7950Support.getInstance())
- .addVersionSpecificSupport(VERSION_1, ChoiceStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, ChoiceStatementSupport.rfc7950Instance())
- .addVersionSpecificSupport(VERSION_1, CaseStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, CaseStatementSupport.rfc7950Instance())
- .addSupport(MustStatementSupport.createInstance(xpathSupport))
- .addSupport(MandatoryStatementSupport.getInstance())
- .addSupport(AnyxmlStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, AnydataStatementSupport.getInstance())
+ private static @NonNull StatementSupportBundle fullDeclarationBundle(final StatementSupportBundle stmtDefBundle,
+ final XPathSupport xpathSupport, final YangParserConfiguration config) {
+ final CaseStatementSupport rfc6020case = CaseStatementSupport.rfc6020Instance(config);
+ final CaseStatementSupport rfc7950case = CaseStatementSupport.rfc7950Instance(config);
+
+ return StatementSupportBundle.derivedFrom(stmtDefBundle)
+ .addSupport(new LeafStatementSupport(config))
+ .addSupport(new ConfigStatementSupport(config))
+ .addSupport(new DeviationStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1, new DeviateStatementRFC6020Support(config))
+ .addVersionSpecificSupport(VERSION_1_1, new DeviateStatementRFC7950Support(config))
+ .addVersionSpecificSupport(VERSION_1, ChoiceStatementSupport.rfc6020Instance(config, rfc6020case))
+ .addVersionSpecificSupport(VERSION_1_1, ChoiceStatementSupport.rfc7950Instance(config, rfc7950case))
+ .addVersionSpecificSupport(VERSION_1, rfc6020case)
+ .addVersionSpecificSupport(VERSION_1_1, rfc7950case)
+ .addSupport(new MustStatementSupport(xpathSupport, config))
+ .addSupport(new MandatoryStatementSupport(config))
+ .addSupport(new AnyxmlStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1_1, new AnydataStatementSupport(config))
.addSupport(FeatureNamespace.BEHAVIOUR)
- .addVersionSpecificSupport(VERSION_1, IfFeatureStatementRFC6020Support.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, IfFeatureStatementRFC7950Support.getInstance())
+ .addVersionSpecificSupport(VERSION_1, new IfFeatureStatementRFC6020Support(config))
+ .addVersionSpecificSupport(VERSION_1_1, new IfFeatureStatementRFC7950Support(config))
.addSupport(GroupingNamespace.BEHAVIOUR)
.addSupport(SourceGroupingNamespace.BEHAVIOUR)
- .addSupport(UsesStatementSupport.getInstance())
- .addSupport(ErrorMessageStatementSupport.getInstance())
- .addSupport(ErrorAppTagStatementSupport.getInstance())
- .addVersionSpecificSupport(VERSION_1, LeafListStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, LeafListStatementSupport.rfc7950Instance())
- .addSupport(PresenceStatementSupport.getInstance())
- .addSupport(MaxElementsStatementSupport.getInstance())
- .addSupport(MinElementsStatementSupport.getInstance())
- .addSupport(OrderedByStatementSupport.getInstance())
- .addSupport(WhenStatementSupport.createInstance(xpathSupport))
+ .addSupport(new UsesStatementSupport(config))
+ .addSupport(new ErrorMessageStatementSupport(config))
+ .addSupport(new ErrorAppTagStatementSupport(config))
+ .addVersionSpecificSupport(VERSION_1, LeafListStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, LeafListStatementSupport.rfc7950Instance(config))
+ .addSupport(new PresenceStatementSupport(config))
+ .addSupport(new MaxElementsStatementSupport(config))
+ .addSupport(new MinElementsStatementSupport(config))
+ .addSupport(new OrderedByStatementSupport(config))
+ .addSupport(new WhenStatementSupport(xpathSupport, config))
.addSupport(AugmentImplicitHandlingNamespace.BEHAVIOUR)
- .addVersionSpecificSupport(VERSION_1, AugmentStatementRFC6020Support.getInstance())
- .addVersionSpecificSupport(VERSION_1_1, AugmentStatementRFC7950Support.getInstance())
+ .addVersionSpecificSupport(VERSION_1, new AugmentStatementRFC6020Support(config))
+ .addVersionSpecificSupport(VERSION_1_1, new AugmentStatementRFC7950Support(config))
.addSupport(RefineTargetNamespace.BEHAVIOUR)
- .addVersionSpecificSupport(VERSION_1, RefineStatementSupport.rfc6020Instance())
- .addVersionSpecificSupport(VERSION_1_1, RefineStatementSupport.rfc7950Instance())
- .addSupport(FeatureStatementSupport.getInstance())
- .addSupport(PositionStatementSupport.getInstance())
- .addSupport(ValueStatementSupport.getInstance())
+ .addVersionSpecificSupport(VERSION_1, RefineStatementSupport.rfc6020Instance(config))
+ .addVersionSpecificSupport(VERSION_1_1, RefineStatementSupport.rfc7950Instance(config))
+ .addSupport(new FeatureStatementSupport(config))
+ .addSupport(new PositionStatementSupport(config))
+ .addSupport(new ValueStatementSupport(config))
.addSupport(YangNamespaceContextNamespace.BEHAVIOUR)
.build();
}
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
- AbstractAugmentStatementSupport() {
+ AbstractAugmentStatementSupport(final YangParserConfiguration config) {
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);
}
@Override
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.WHEN)
.build();
- private static final AugmentStatementRFC6020Support INSTANCE = new AugmentStatementRFC6020Support();
- private AugmentStatementRFC6020Support() {
- // Hidden
- }
-
- public static AugmentStatementRFC6020Support getInstance() {
- return INSTANCE;
+ public AugmentStatementRFC6020Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.WHEN)
.build();
- private static final AugmentStatementRFC7950Support INSTANCE = new AugmentStatementRFC7950Support();
- private AugmentStatementRFC7950Support() {
- // Hidden
- }
-
- public static AugmentStatementRFC7950Support getInstance() {
- return INSTANCE;
+ public AugmentStatementRFC7950Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.DeviateEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles;
private static final ImmutableSet<YangStmtMapping> IMPLICIT_STATEMENTS = ImmutableSet.of(YangStmtMapping.CONFIG,
YangStmtMapping.MANDATORY, YangStmtMapping.MAX_ELEMENTS, YangStmtMapping.MIN_ELEMENTS);
- AbstractDeviateStatementSupport() {
- super(YangStmtMapping.DEVIATE, StatementPolicy.contextIndependent());
+ AbstractDeviateStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.DEVIATE, StatementPolicy.contextIndependent(), config);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate;
-public final class DeviateStatementRFC6020Support extends AbstractDeviateStatementSupport {
- private static final DeviateStatementRFC6020Support INSTANCE = new DeviateStatementRFC6020Support();
-
- private DeviateStatementRFC6020Support() {
- // Hidden
- }
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
- public static DeviateStatementRFC6020Support getInstance() {
- return INSTANCE;
+public final class DeviateStatementRFC6020Support extends AbstractDeviateStatementSupport {
+ public DeviateStatementRFC6020Support(final YangParserConfiguration config) {
+ super(config);
}
}
\ No newline at end of file
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
/**
.addAny(YangStmtMapping.UNIQUE)
.addOptional(YangStmtMapping.UNITS)
.build();
- private static final DeviateStatementRFC7950Support INSTANCE = new DeviateStatementRFC7950Support();
- private DeviateStatementRFC7950Support() {
- // Hidden
- }
-
- public static DeviateStatementRFC7950Support getInstance() {
- return INSTANCE;
+ public DeviateStatementRFC7950Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
public final class ExtensionStatementSupport
extends AbstractQNameStatementSupport<ExtensionStatement, ExtensionEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .EXTENSION)
- .addOptional(YangStmtMapping.ARGUMENT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .build();
- private static final ExtensionStatementSupport INSTANCE = new ExtensionStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.EXTENSION)
+ .addOptional(YangStmtMapping.ARGUMENT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .build();
- private ExtensionStatementSupport() {
- super(YangStmtMapping.EXTENSION, StatementPolicy.reject());
- }
+ private final YangParserConfiguration config;
- public static ExtensionStatementSupport getInstance() {
- return INSTANCE;
+ public ExtensionStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.EXTENSION, StatementPolicy.reject(), config);
+ this.config = requireNonNull(config);
}
@Override
stmt.addToNs(StatementDefinitionNamespace.class, stmt.argument(),
new UnrecognizedStatementSupport(new ModelDefinedStatementDefinition(stmt.getArgument(),
- argument != null ? argument.argument() : null, yinElement != null && yinElement.getArgument())));
+ argument != null ? argument.argument() : null, yinElement != null && yinElement.getArgument()),
+ config));
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
final class UnrecognizedStatementSupport
extends AbstractStatementSupport<Object, UnrecognizedStatement, UnrecognizedEffectiveStatement>
implements OverrideChildStatementSupport {
- UnrecognizedStatementSupport(final StatementDefinition publicDefinition) {
+ private final YangParserConfiguration config;
+
+ 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());
+ super(publicDefinition, StatementPolicy.exactReplica(), config);
+ this.config = requireNonNull(config);
}
@Override
} else {
def = new ModelDefinedStatementDefinition(statementName);
}
- return new UnrecognizedStatementSupport(def);
+ return new UnrecognizedStatementSupport(def, config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.FeatureNamespace;
YangStmtMapping.IF_FEATURE)
.build();
- AbstractIfFeatureStatementSupport() {
- super(YangStmtMapping.IF_FEATURE, StatementPolicy.contextIndependent());
+ AbstractIfFeatureStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.IF_FEATURE, StatementPolicy.contextIndependent(), config);
}
@Override
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
public final class IfFeatureStatementRFC6020Support extends AbstractIfFeatureStatementSupport {
- private static final IfFeatureStatementRFC6020Support INSTANCE = new IfFeatureStatementRFC6020Support();
-
- private IfFeatureStatementRFC6020Support() {
- // Hidden on purpose
- }
-
- public static IfFeatureStatementRFC6020Support getInstance() {
- return INSTANCE;
+ public IfFeatureStatementRFC6020Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public final class IfFeatureStatementRFC7950Support extends AbstractIfFeatureStatementSupport {
- private static final IfFeatureStatementRFC7950Support INSTANCE = new IfFeatureStatementRFC7950Support();
-
- private IfFeatureStatementRFC7950Support() {
- // Hidden on purpose
- }
-
- public static IfFeatureStatementRFC7950Support getInstance() {
- return INSTANCE;
+ public IfFeatureStatementRFC7950Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
@Beta
public final class ImportStatementSupport
extends AbstractStringStatementSupport<ImportStatement, ImportEffectiveStatement> {
- private static final @NonNull ImportStatementSupport RFC6020_INSTANCE = new ImportStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.IMPORT)
.addMandatory(YangStmtMapping.PREFIX)
.addOptional(YangStmtMapping.REVISION_DATE)
.addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
- .build());
- private static final @NonNull ImportStatementSupport RFC7950_INSTANCE = new ImportStatementSupport(
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.IMPORT)
.addMandatory(YangStmtMapping.PREFIX)
.addOptional(YangStmtMapping.REVISION_DATE)
.addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.REFERENCE)
- .build());
+ .build();
private final SubstatementValidator validator;
- private ImportStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.IMPORT, StatementPolicy.reject());
+ private ImportStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.IMPORT, StatementPolicy.reject(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull ImportStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull ImportStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new ImportStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull ImportStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull ImportStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new ImportStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
@Beta
public final class LeafListStatementSupport
extends AbstractSchemaTreeStatementSupport<LeafListStatement, LeafListEffectiveStatement> {
- private static final @NonNull LeafListStatementSupport RFC6020_INSTANCE = new LeafListStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.LEAF_LIST)
.addOptional(YangStmtMapping.CONFIG)
.addOptional(YangStmtMapping.DESCRIPTION)
.addMandatory(YangStmtMapping.TYPE)
.addOptional(YangStmtMapping.UNITS)
.addOptional(YangStmtMapping.WHEN)
- .build());
- private static final @NonNull LeafListStatementSupport RFC7950_INSTANCE = new LeafListStatementSupport(
- SubstatementValidator.builder(YangStmtMapping
- .LEAF_LIST)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.LEAF_LIST)
.addOptional(YangStmtMapping.CONFIG)
.addAny(YangStmtMapping.DEFAULT)
.addOptional(YangStmtMapping.DESCRIPTION)
.addMandatory(YangStmtMapping.TYPE)
.addOptional(YangStmtMapping.UNITS)
.addOptional(YangStmtMapping.WHEN)
- .build());
+ .build();
private final SubstatementValidator validator;
- private LeafListStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.LEAF_LIST, instantiatedPolicy());
+ private LeafListStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.LEAF_LIST, instantiatedPolicy(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull LeafListStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull LeafListStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new LeafListStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull LeafListStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull LeafListStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new LeafListStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.model.spi.meta.SubstatementIndexingException;
private static final ImmutableSet<YangStmtMapping> UNINSTANTIATED_DATATREE_STATEMENTS = ImmutableSet.of(
YangStmtMapping.GROUPING, YangStmtMapping.NOTIFICATION, YangStmtMapping.INPUT, YangStmtMapping.OUTPUT);
- private static final @NonNull ListStatementSupport RFC6020_INSTANCE = new ListStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONFIG)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.KEY)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.ORDERED_BY)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.UNIQUE)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.WHEN)
- .build());
- private static final @NonNull ListStatementSupport RFC7950_INSTANCE = new ListStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.ACTION)
- .addAny(YangStmtMapping.ANYDATA)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONFIG)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.KEY)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addAny(YangStmtMapping.MUST)
- .addAny(YangStmtMapping.NOTIFICATION)
- .addOptional(YangStmtMapping.ORDERED_BY)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.UNIQUE)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.WHEN)
- .build());
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.KEY)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.ORDERED_BY)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.UNIQUE)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.ACTION)
+ .addAny(YangStmtMapping.ANYDATA)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.KEY)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addAny(YangStmtMapping.MUST)
+ .addAny(YangStmtMapping.NOTIFICATION)
+ .addOptional(YangStmtMapping.ORDERED_BY)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.UNIQUE)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
private final SubstatementValidator validator;
- ListStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.LIST, instantiatedPolicy());
+ ListStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.LIST, instantiatedPolicy(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull ListStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull ListStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new ListStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull ListStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull ListStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new ListStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
abstract class AbstractImplicitStatementSupport<D extends DeclaredStatement<QName>,
E extends SchemaTreeEffectiveStatement<D>> extends AbstractSchemaTreeStatementSupport<D, E> {
AbstractImplicitStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<QName, D> policy) {
- super(publicDefinition, policy);
+ final StatementPolicy<QName, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins;
import org.opendaylight.yangtools.yang.model.spi.meta.SubstatementIndexingException;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
private final Function<QNameModule, QName> createArgument;
AbstractOperationContainerStatementSupport(final StatementDefinition publicDefinition,
- final Function<QNameModule, QName> createArgument) {
- super(publicDefinition, uninstantiatedPolicy());
+ final YangParserConfiguration config, final Function<QNameModule, QName> createArgument) {
+ super(publicDefinition, uninstantiatedPolicy(), config);
this.createArgument = requireNonNull(createArgument);
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins;
private static final ImmutableSet<StatementDefinition> ILLEGAL_PARENTS = ImmutableSet.of(
YangStmtMapping.NOTIFICATION, YangStmtMapping.RPC, YangStmtMapping.ACTION);
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.ACTION)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.INPUT)
- .addOptional(YangStmtMapping.OUTPUT)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .build();
- private static final ActionStatementSupport INSTANCE = new ActionStatementSupport();
-
- private ActionStatementSupport() {
- super(YangStmtMapping.ACTION, uninstantiatedPolicy());
- }
-
- public static ActionStatementSupport getInstance() {
- return INSTANCE;
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ACTION)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.INPUT)
+ .addOptional(YangStmtMapping.OUTPUT)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .build();
+
+ private final InputStatementSupport implicitInput;
+ private final OutputStatementSupport implicitOutput;
+
+ public ActionStatementSupport(final YangParserConfiguration config, final InputStatementSupport implicitInput,
+ final OutputStatementSupport implicitOutput) {
+ super(YangStmtMapping.ACTION, uninstantiatedPolicy(), config);
+ this.implicitInput = requireNonNull(implicitInput);
+ this.implicitOutput = requireNonNull(implicitOutput);
}
@Override
verify(stmt instanceof StatementContextBase);
if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
- ((StatementContextBase<?, ?, ?>) stmt).appendImplicitSubstatement(
- InputStatementSupport.rfc7950Instance(), null);
+ ((StatementContextBase<?, ?, ?>) stmt).appendImplicitSubstatement(implicitInput, null);
}
if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) {
- ((StatementContextBase<?, ?, ?>) stmt).appendImplicitSubstatement(
- OutputStatementSupport.rfc7950Instance(), null);
+ ((StatementContextBase<?, ?, ?>) stmt).appendImplicitSubstatement(implicitOutput, null);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
public final class AnydataStatementSupport
extends AbstractSchemaTreeStatementSupport<AnydataStatement, AnydataEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.ANYDATA)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
- private static final AnydataStatementSupport INSTANCE = new AnydataStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ANYDATA)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
- private AnydataStatementSupport() {
- super(YangStmtMapping.ANYDATA, instantiatedPolicy());
- }
-
- public static AnydataStatementSupport getInstance() {
- return INSTANCE;
+ public AnydataStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ANYDATA, instantiatedPolicy(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
public final class AnyxmlStatementSupport
extends AbstractSchemaTreeStatementSupport<AnyxmlStatement, AnyxmlEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ANYXML)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
- private static final AnyxmlStatementSupport INSTANCE = new AnyxmlStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ANYXML)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
- private AnyxmlStatementSupport() {
- super(YangStmtMapping.ANYXML, instantiatedPolicy());
- }
-
- public static AnyxmlStatementSupport getInstance() {
- return INSTANCE;
+ public AnyxmlStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ANYXML, instantiatedPolicy(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
public final class ArgumentStatementSupport
extends AbstractQNameStatementSupport<ArgumentStatement, ArgumentEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ARGUMENT)
- .addOptional(YangStmtMapping.YIN_ELEMENT)
- .build();
- private static final ArgumentStatementSupport INSTANCE = new ArgumentStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ARGUMENT).addOptional(YangStmtMapping.YIN_ELEMENT).build();
- private ArgumentStatementSupport() {
- super(YangStmtMapping.ARGUMENT, StatementPolicy.reject());
- }
-
- public static ArgumentStatementSupport getInstance() {
- return INSTANCE;
+ public ArgumentStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ARGUMENT, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
public final class BaseStatementSupport extends AbstractQNameStatementSupport<BaseStatement, BaseEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.BASE).build();
- private static final BaseStatementSupport INSTANCE = new BaseStatementSupport();
- private BaseStatementSupport() {
- super(YangStmtMapping.BASE, StatementPolicy.contextIndependent());
- }
-
- public static BaseStatementSupport getInstance() {
- return INSTANCE;
+ public BaseStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.BASE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
extends AbstractStringStatementSupport<BelongsToStatement, BelongsToEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.BELONGS_TO).addMandatory(YangStmtMapping.PREFIX).build();
- private static final BelongsToStatementSupport INSTANCE = new BelongsToStatementSupport();
- private BelongsToStatementSupport() {
- super(YangStmtMapping.BELONGS_TO, StatementPolicy.reject());
- }
-
- public static BelongsToStatementSupport getInstance() {
- return INSTANCE;
+ public BelongsToStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.BELONGS_TO, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BitEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
@Beta
public final class BitStatementSupport extends AbstractStatementSupport<String, BitStatement, BitEffectiveStatement> {
- private static final @NonNull BitStatementSupport RFC6020_INSTANCE = new BitStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.BIT)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.POSITION)
- .build());
- private static final @NonNull BitStatementSupport RFC7950_INSTANCE = new BitStatementSupport(
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.BIT)
.addOptional(YangStmtMapping.DESCRIPTION)
.addAny(YangStmtMapping.IF_FEATURE)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.POSITION)
- .build());
+ .build();
private final SubstatementValidator validator;
- private BitStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.BIT, StatementPolicy.contextIndependent());
+ private BitStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.BIT, StatementPolicy.contextIndependent(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull BitStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull BitStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new BitStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull BitStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull BitStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new BitStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.ImplicitStatements;
@Beta
public final class CaseStatementSupport
extends AbstractImplicitStatementSupport<CaseStatement, CaseEffectiveStatement> {
- private static final @NonNull CaseStatementSupport RFC6020_INSTANCE = new CaseStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.CASE)
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.CASE)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CHOICE)
.addAny(YangStmtMapping.CONTAINER)
.addOptional(YangStmtMapping.STATUS)
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.WHEN)
- .build());
- private static final @NonNull CaseStatementSupport RFC7950_INSTANCE = new CaseStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.CASE)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.CASE)
.addAny(YangStmtMapping.ANYDATA)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CHOICE)
.addOptional(YangStmtMapping.STATUS)
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.WHEN)
- .build());
+ .build();
private final SubstatementValidator validator;
- private CaseStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.CASE, instantiatedPolicy());
+ private CaseStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.CASE, instantiatedPolicy(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull CaseStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull CaseStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new CaseStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull CaseStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull CaseStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new CaseStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
public final class ChoiceStatementSupport
extends AbstractSchemaTreeStatementSupport<ChoiceStatement, ChoiceEffectiveStatement>
implements ImplicitParentAwareStatementSupport {
- private static final @NonNull ChoiceStatementSupport RFC6020_INSTANCE = new ChoiceStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.CHOICE)
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.CHOICE)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CASE)
.addOptional(YangStmtMapping.CONFIG)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.WHEN)
- .build(),
- CaseStatementSupport.rfc6020Instance());
+ .build();
- private static final @NonNull ChoiceStatementSupport RFC7950_INSTANCE = new ChoiceStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.CHOICE)
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.CHOICE)
.addAny(YangStmtMapping.ANYDATA)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CASE)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.WHEN)
- .build(),
- CaseStatementSupport.rfc7950Instance());
+ .build();
private final SubstatementValidator validator;
private final CaseStatementSupport implicitCase;
- private ChoiceStatementSupport(final SubstatementValidator validator, final CaseStatementSupport implicitCase) {
- super(YangStmtMapping.CHOICE, instantiatedPolicy());
+ private ChoiceStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator,
+ final CaseStatementSupport implicitCase) {
+ super(YangStmtMapping.CHOICE, instantiatedPolicy(), config);
this.validator = requireNonNull(validator);
this.implicitCase = requireNonNull(implicitCase);
}
- public static @NonNull ChoiceStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull ChoiceStatementSupport rfc6020Instance(final YangParserConfiguration config,
+ final CaseStatementSupport implicitCase) {
+ return new ChoiceStatementSupport(config, RFC6020_VALIDATOR, implicitCase);
}
- public static @NonNull ChoiceStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull ChoiceStatementSupport rfc7950Instance(final YangParserConfiguration config,
+ final CaseStatementSupport implicitCase) {
+ return new ChoiceStatementSupport(config, RFC7950_VALIDATOR, implicitCase);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport;
public final class ConfigStatementSupport
extends AbstractBooleanStatementSupport<ConfigStatement, ConfigEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.CONFIG).build();
- private static final ConfigStatementSupport INSTANCE = new ConfigStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.CONFIG).build();
- private ConfigStatementSupport() {
+ public ConfigStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.CONFIG,
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());
- }
-
- public static ConfigStatementSupport getInstance() {
- return INSTANCE;
+ StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStringStatementSupport;
public final class ContactStatementSupport
extends AbstractInternedStringStatementSupport<ContactStatement, ContactEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.CONTACT).build();
- private static final ContactStatementSupport INSTANCE = new ContactStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.CONTACT).build();
- private ContactStatementSupport() {
- super(YangStmtMapping.CONTACT, StatementPolicy.reject());
- }
-
- public static ContactStatementSupport getInstance() {
- return INSTANCE;
+ public ContactStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.CONTACT, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
@Beta
public final class ContainerStatementSupport
extends AbstractSchemaTreeStatementSupport<ContainerStatement, ContainerEffectiveStatement> {
- private static final @NonNull ContainerStatementSupport RFC6020_INSTANCE = new ContainerStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.CONTAINER)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CHOICE)
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.WHEN)
- .build());
+ .build();
- private static final @NonNull ContainerStatementSupport RFC7950_INSTANCE = new ContainerStatementSupport(
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.CONTAINER)
.addAny(YangStmtMapping.ACTION)
.addAny(YangStmtMapping.ANYDATA)
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.WHEN)
- .build());
+ .build();
private final SubstatementValidator validator;
- private ContainerStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.CONTAINER, instantiatedPolicy());
+ private ContainerStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.CONTAINER, instantiatedPolicy(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull ContainerStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull ContainerStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new ContainerStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull ContainerStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull ContainerStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new ContainerStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class DefaultStatementSupport
extends AbstractStringStatementSupport<DefaultStatement, DefaultEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.DEFAULT).build();
- private static final DefaultStatementSupport INSTANCE = new DefaultStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DEFAULT).build();
- private DefaultStatementSupport() {
+ public DefaultStatementSupport(final YangParserConfiguration config) {
// Note: if we start interpreting the string we'll need to use StatementPolicy.declaredCopy()
- super(YangStmtMapping.DEFAULT, StatementPolicy.contextIndependent());
- }
-
- public static DefaultStatementSupport getInstance() {
- return INSTANCE;
+ super(YangStmtMapping.DEFAULT, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class DescriptionStatementSupport
extends AbstractStringStatementSupport<DescriptionStatement, DescriptionEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.DESCRIPTION).build();
- private static final DescriptionStatementSupport INSTANCE = new DescriptionStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DESCRIPTION).build();
- private DescriptionStatementSupport() {
- super(YangStmtMapping.DESCRIPTION, StatementPolicy.contextIndependent());
- }
-
- public static DescriptionStatementSupport getInstance() {
- return INSTANCE;
+ public DescriptionStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.DESCRIPTION, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.DeviationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
.addAny(YangStmtMapping.DEVIATE)
.addOptional(YangStmtMapping.REFERENCE)
.build();
- private static final DeviationStatementSupport INSTANCE = new DeviationStatementSupport();
- private DeviationStatementSupport() {
- super(YangStmtMapping.DEVIATION, StatementPolicy.reject());
- }
-
- public static DeviationStatementSupport getInstance() {
- return INSTANCE;
+ public DeviationStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.DEVIATION, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
@Beta
public final class EnumStatementSupport
extends AbstractStatementSupport<String, EnumStatement, EnumEffectiveStatement> {
- private static final @NonNull EnumStatementSupport RFC6020_INSTANCE = new EnumStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.ENUM)
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.ENUM)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.VALUE)
- .build());
- private static final @NonNull EnumStatementSupport RFC7950_INSTANCE = new EnumStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.ENUM)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.ENUM)
.addOptional(YangStmtMapping.DESCRIPTION)
.addAny(YangStmtMapping.IF_FEATURE)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.VALUE)
- .build());
+ .build();
private final SubstatementValidator validator;
- private EnumStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.ENUM, StatementPolicy.contextIndependent());
+ private EnumStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.ENUM, StatementPolicy.contextIndependent(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull EnumStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull EnumStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new EnumStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull EnumStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull EnumStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new EnumStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
extends AbstractStringStatementSupport<ErrorAppTagStatement, ErrorAppTagEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
YangStmtMapping.ERROR_APP_TAG).build();
- private static final ErrorAppTagStatementSupport INSTANCE = new ErrorAppTagStatementSupport();
- private ErrorAppTagStatementSupport() {
- super(YangStmtMapping.ERROR_APP_TAG, StatementPolicy.contextIndependent());
- }
-
- public static ErrorAppTagStatementSupport getInstance() {
- return INSTANCE;
+ public ErrorAppTagStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ERROR_APP_TAG, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class ErrorMessageStatementSupport
extends AbstractStringStatementSupport<ErrorMessageStatement, ErrorMessageEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.ERROR_MESSAGE).build();
- private static final ErrorMessageStatementSupport INSTANCE = new ErrorMessageStatementSupport();
+ SubstatementValidator.builder(YangStmtMapping.ERROR_MESSAGE).build();
- private ErrorMessageStatementSupport() {
- super(YangStmtMapping.ERROR_MESSAGE, StatementPolicy.contextIndependent());
- }
-
- public static ErrorMessageStatementSupport getInstance() {
- return INSTANCE;
+ public ErrorMessageStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ERROR_MESSAGE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
public final class FeatureStatementSupport
extends AbstractQNameStatementSupport<FeatureStatement, FeatureEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.FEATURE)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
- private static final FeatureStatementSupport INSTANCE = new FeatureStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.FEATURE)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
- private FeatureStatementSupport() {
- super(YangStmtMapping.FEATURE, StatementPolicy.reject());
- }
-
- public static FeatureStatementSupport getInstance() {
- return INSTANCE;
+ public FeatureStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.FEATURE, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
extends AbstractStatementSupport<Integer, FractionDigitsStatement, FractionDigitsEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.FRACTION_DIGITS).build();
- private static final FractionDigitsStatementSupport INSTANCE = new FractionDigitsStatementSupport();
// FIXME: move this to yang-model-spi
private static final ImmutableMap<FractionDigitsStatement, FractionDigitsEffectiveStatement> EMPTY_EFF;
EMPTY_EFF = effBuilder.build();
}
- private FractionDigitsStatementSupport() {
- super(YangStmtMapping.FRACTION_DIGITS, StatementPolicy.contextIndependent());
- }
-
- public static FractionDigitsStatementSupport getInstance() {
- return INSTANCE;
+ public FractionDigitsStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.FRACTION_DIGITS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins;
@Beta
public final class GroupingStatementSupport
extends AbstractQNameStatementSupport<GroupingStatement, GroupingEffectiveStatement> {
- private static final @NonNull GroupingStatementSupport RFC6020_INSTANCE = new GroupingStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.GROUPING)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CHOICE)
.addOptional(YangStmtMapping.STATUS)
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
- .build());
- private static final @NonNull GroupingStatementSupport RFC7950_INSTANCE = new GroupingStatementSupport(
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.GROUPING)
.addAny(YangStmtMapping.ACTION)
.addAny(YangStmtMapping.ANYDATA)
.addOptional(YangStmtMapping.STATUS)
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
- .build());
+ .build();
private final SubstatementValidator validator;
- GroupingStatementSupport(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)));
+ && copy.equalParentPath(current)), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull GroupingStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull GroupingStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new GroupingStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull GroupingStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull GroupingStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new GroupingStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
@Beta
public final class IdentityStatementSupport
extends AbstractQNameStatementSupport<IdentityStatement, IdentityEffectiveStatement> {
- private static final @NonNull IdentityStatementSupport RFC6020_INSTANCE = new IdentityStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.IDENTITY)
.addOptional(YangStmtMapping.BASE)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
- .build());
- private static final @NonNull IdentityStatementSupport RFC7950_INSTANCE = new IdentityStatementSupport(
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.IDENTITY)
.addAny(YangStmtMapping.BASE)
.addOptional(YangStmtMapping.DESCRIPTION)
.addAny(YangStmtMapping.IF_FEATURE)
.addOptional(YangStmtMapping.REFERENCE)
.addOptional(YangStmtMapping.STATUS)
- .build());
+ .build();
private final SubstatementValidator validator;
- private IdentityStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.IDENTITY, StatementPolicy.reject());
+ private IdentityStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.IDENTITY, StatementPolicy.reject(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull IdentityStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull IdentityStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new IdentityStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull IdentityStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull IdentityStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new IdentityStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
@Beta
public final class IncludeStatementSupport
extends AbstractStringStatementSupport<IncludeStatement, IncludeEffectiveStatement> {
- private static final @NonNull IncludeStatementSupport RFC6020_INSTANCE = new IncludeStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.INCLUDE).addOptional(YangStmtMapping.REVISION_DATE).build());
- private static final @NonNull IncludeStatementSupport RFC7950_INSTANCE = new IncludeStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.INCLUDE)
+ .addOptional(YangStmtMapping.REVISION_DATE)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.INCLUDE)
.addOptional(YangStmtMapping.REVISION_DATE)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.REFERENCE)
- .build());
+ .build();
private final SubstatementValidator validator;
- IncludeStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.INCLUDE, StatementPolicy.reject());
+ IncludeStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.INCLUDE, StatementPolicy.reject(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull IncludeStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull IncludeStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new IncludeStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull IncludeStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull IncludeStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new IncludeStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.ImplicitStatements;
@Beta
public final class InputStatementSupport
extends AbstractOperationContainerStatementSupport<InputStatement, InputEffectiveStatement> {
- private static final @NonNull InputStatementSupport RFC6020_INSTANCE = new InputStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.INPUT)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build());
- private static final @NonNull InputStatementSupport RFC7950_INSTANCE = new InputStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.INPUT)
- .addAny(YangStmtMapping.ANYDATA)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.MUST)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build());
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.INPUT)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.INPUT)
+ .addAny(YangStmtMapping.ANYDATA)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.MUST)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
private final SubstatementValidator validator;
- private InputStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.INPUT, YangConstants::operationInputQName);
+ private InputStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.INPUT, config, YangConstants::operationInputQName);
this.validator = requireNonNull(validator);
}
- public static @NonNull InputStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull InputStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new InputStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull InputStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull InputStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new InputStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.antlr.YangStatementLexer;
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.KEY).build();
- private static final KeyStatementSupport INSTANCE = new KeyStatementSupport();
- private KeyStatementSupport() {
+ 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()));
- }
-
- public static KeyStatementSupport getInstance() {
- return INSTANCE;
+ (copy, current, substatements) -> copy.getArgument() == current.getArgument()), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
public final class LeafStatementSupport
extends AbstractSchemaTreeStatementSupport<LeafStatement, LeafEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .LEAF)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addMandatory(YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.UNITS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
- private static final LeafStatementSupport INSTANCE = new LeafStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.LEAF)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addMandatory(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.UNITS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
- private LeafStatementSupport() {
- super(YangStmtMapping.LEAF, instantiatedPolicy());
- }
-
- public static LeafStatementSupport getInstance() {
- return INSTANCE;
+ public LeafStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.LEAF, instantiatedPolicy(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
public final class LengthStatementSupport
extends AbstractStatementSupport<List<ValueRange>, LengthStatement, LengthEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .LENGTH)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.ERROR_APP_TAG)
- .addOptional(YangStmtMapping.ERROR_MESSAGE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
- private static final LengthStatementSupport INSTANCE = new LengthStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.LENGTH)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.ERROR_APP_TAG)
+ .addOptional(YangStmtMapping.ERROR_MESSAGE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
- private LengthStatementSupport() {
- super(YangStmtMapping.LENGTH, StatementPolicy.contextIndependent());
- }
-
- public static LengthStatementSupport getInstance() {
- return INSTANCE;
+ public LengthStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.LENGTH, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport;
public final class MandatoryStatementSupport extends
AbstractBooleanStatementSupport<MandatoryStatement, MandatoryEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.MANDATORY).build();
- private static final MandatoryStatementSupport INSTANCE = new MandatoryStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.MANDATORY).build();
- private MandatoryStatementSupport() {
+ public MandatoryStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.MANDATORY,
EffectiveStatements.createMandatory(DeclaredStatements.createMandatory(Boolean.FALSE)),
EffectiveStatements.createMandatory(DeclaredStatements.createMandatory(Boolean.TRUE)),
- StatementPolicy.contextIndependent());
- }
-
- public static MandatoryStatementSupport getInstance() {
- return INSTANCE;
+ StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class MaxElementsStatementSupport
extends AbstractStringStatementSupport<MaxElementsStatement, MaxElementsEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.MAX_ELEMENTS)
- .build();
- private static final MaxElementsStatementSupport INSTANCE = new MaxElementsStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.MAX_ELEMENTS).build();
- private MaxElementsStatementSupport() {
- super(YangStmtMapping.MAX_ELEMENTS, StatementPolicy.contextIndependent());
- }
-
- public static MaxElementsStatementSupport getInstance() {
- return INSTANCE;
+ public MaxElementsStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.MAX_ELEMENTS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStatementSupport;
public final class MinElementsStatementSupport
extends AbstractInternedStatementSupport<Integer, MinElementsStatement, MinElementsEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.MIN_ELEMENTS)
- .build();
- private static final MinElementsStatementSupport INSTANCE = new MinElementsStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.MIN_ELEMENTS).build();
- private MinElementsStatementSupport() {
- super(YangStmtMapping.MIN_ELEMENTS, StatementPolicy.contextIndependent());
- }
-
- public static MinElementsStatementSupport getInstance() {
- return INSTANCE;
+ public MinElementsStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.MIN_ELEMENTS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
public final class ModifierStatementSupport
extends AbstractStatementSupport<ModifierKind, ModifierStatement, ModifierEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.MODIFIER).build();
- private static final ModifierStatementSupport INSTANCE = new ModifierStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.MODIFIER).build();
- private ModifierStatementSupport() {
- super(YangStmtMapping.MODIFIER, StatementPolicy.contextIndependent());
- }
-
- public static ModifierStatementSupport getInstance() {
- return INSTANCE;
+ public ModifierStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.MODIFIER, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
private final @NonNull XPathSupport xpathSupport;
- private MustStatementSupport(final XPathSupport xpathSupport) {
+ 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());
+ super(YangStmtMapping.MUST, StatementPolicy.contextIndependent(), config);
this.xpathSupport = requireNonNull(xpathSupport);
}
- public static MustStatementSupport createInstance(final XPathSupport xpathSupport) {
- return new MustStatementSupport(xpathSupport);
- }
-
@Override
public QualifiedBound parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return xpathSupport.parseXPath(ctx, value);
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
public final class NamespaceStatementSupport
extends AbstractStatementSupport<XMLNamespace, NamespaceStatement, NamespaceEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .NAMESPACE)
- .build();
- private static final NamespaceStatementSupport INSTANCE = new NamespaceStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.NAMESPACE).build();
- private NamespaceStatementSupport() {
- super(YangStmtMapping.NAMESPACE, StatementPolicy.reject());
- }
-
- public static NamespaceStatementSupport getInstance() {
- return INSTANCE;
+ public NamespaceStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.NAMESPACE, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
extends AbstractStatementSupport<Ordering, OrderedByStatement, OrderedByEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.ORDERED_BY).build();
- private static final OrderedByStatementSupport INSTANCE = new OrderedByStatementSupport();
/*
* Ordered-by has low argument cardinality, hence we can reuse them in case declaration does not have any
private static final @NonNull OrderedByEffectiveStatement EMPTY_USER_EFF =
EffectiveStatements.createOrderedBy(EMPTY_USER_DECL);
- private OrderedByStatementSupport() {
- super(YangStmtMapping.ORDERED_BY, StatementPolicy.contextIndependent());
- }
-
- public static OrderedByStatementSupport getInstance() {
- return INSTANCE;
+ public OrderedByStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ORDERED_BY, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStringStatementSupport;
public final class OrganizationStatementSupport
extends AbstractInternedStringStatementSupport<OrganizationStatement, OrganizationEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.ORGANIZATION)
- .build();
- private static final OrganizationStatementSupport INSTANCE = new OrganizationStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ORGANIZATION).build();
- private OrganizationStatementSupport() {
- super(YangStmtMapping.ORGANIZATION, StatementPolicy.reject());
- }
-
- public static OrganizationStatementSupport getInstance() {
- return INSTANCE;
+ public OrganizationStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.ORGANIZATION, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.ImplicitStatements;
@Beta
public final class OutputStatementSupport
extends AbstractOperationContainerStatementSupport<OutputStatement, OutputEffectiveStatement> {
- private static final @NonNull OutputStatementSupport RFC6020_INSTANCE = new OutputStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.OUTPUT)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build());
- private static final @NonNull OutputStatementSupport RFC7950_INSTANCE = new OutputStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.OUTPUT)
- .addAny(YangStmtMapping.ANYDATA)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.MUST)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build());
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.OUTPUT)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.OUTPUT)
+ .addAny(YangStmtMapping.ANYDATA)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.MUST)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
private final SubstatementValidator validator;
- private OutputStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.OUTPUT, YangConstants::operationOutputQName);
+ private OutputStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.OUTPUT, config, YangConstants::operationOutputQName);
this.validator = requireNonNull(validator);
}
- public static @NonNull OutputStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull OutputStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new OutputStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull OutputStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull OutputStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new OutputStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStatementSupport;
public final class PositionStatementSupport
extends AbstractInternedStatementSupport<Uint32, PositionStatement, PositionEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.POSITION).build();
- private static final PositionStatementSupport INSTANCE = new PositionStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.POSITION).build();
- private PositionStatementSupport() {
- super(YangStmtMapping.POSITION, StatementPolicy.contextIndependent());
- }
-
- public static PositionStatementSupport getInstance() {
- return INSTANCE;
+ public PositionStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.POSITION, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class PrefixStatementSupport
extends AbstractStringStatementSupport<PrefixStatement, PrefixEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.PREFIX).build();
- private static final PrefixStatementSupport INSTANCE = new PrefixStatementSupport();
+ SubstatementValidator.builder(YangStmtMapping.PREFIX).build();
- private PrefixStatementSupport() {
- super(YangStmtMapping.PREFIX, StatementPolicy.reject());
- }
-
- public static PrefixStatementSupport getInstance() {
- return INSTANCE;
+ public PrefixStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.PREFIX, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class PresenceStatementSupport
extends AbstractStringStatementSupport<PresenceStatement, PresenceEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.PRESENCE).build();
- private static final PresenceStatementSupport INSTANCE = new PresenceStatementSupport();
+ SubstatementValidator.builder(YangStmtMapping.PRESENCE).build();
- private PresenceStatementSupport() {
- super(YangStmtMapping.PRESENCE, StatementPolicy.contextIndependent());
- }
-
- public static PresenceStatementSupport getInstance() {
- return INSTANCE;
+ public PresenceStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.PRESENCE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
.addOptional(YangStmtMapping.ERROR_MESSAGE)
.addOptional(YangStmtMapping.REFERENCE)
.build();
- private static final RangeStatementSupport INSTANCE = new RangeStatementSupport();
- private RangeStatementSupport() {
- super(YangStmtMapping.RANGE, StatementPolicy.contextIndependent());
- }
-
- public static RangeStatementSupport getInstance() {
- return INSTANCE;
+ public RangeStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.RANGE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStringStatementSupport;
public final class ReferenceStatementSupport
extends AbstractInternedStringStatementSupport<ReferenceStatement, ReferenceEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.REFERENCE)
- .build();
- private static final ReferenceStatementSupport INSTANCE = new ReferenceStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.REFERENCE).build();
- private ReferenceStatementSupport() {
- super(YangStmtMapping.REFERENCE, StatementPolicy.contextIndependent());
- }
-
- public static ReferenceStatementSupport getInstance() {
- return INSTANCE;
+ public ReferenceStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.REFERENCE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport;
public final class RequireInstanceStatementSupport
extends AbstractBooleanStatementSupport<RequireInstanceStatement, RequireInstanceEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.REQUIRE_INSTANCE).build();
- private static final RequireInstanceStatementSupport INSTANCE = new RequireInstanceStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.REQUIRE_INSTANCE).build();
- private RequireInstanceStatementSupport() {
+ public RequireInstanceStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.REQUIRE_INSTANCE,
EffectiveStatements.createRequireInstance(false), EffectiveStatements.createRequireInstance(true),
- StatementPolicy.contextIndependent());
- }
-
- public static RequireInstanceStatementSupport getInstance() {
- return INSTANCE;
+ StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
public final class RevisionDateStatementSupport
extends AbstractStatementSupport<Revision, RevisionDateStatement, RevisionDateEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.REVISION_DATE).build();
- private static final RevisionDateStatementSupport INSTANCE = new RevisionDateStatementSupport();
+ SubstatementValidator.builder(YangStmtMapping.REVISION_DATE).build();
- private RevisionDateStatementSupport() {
- super(YangStmtMapping.REVISION_DATE, StatementPolicy.contextIndependent());
- }
-
- public static RevisionDateStatementSupport getInstance() {
- return INSTANCE;
+ public RevisionDateStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.REVISION_DATE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
public final class RevisionStatementSupport
extends AbstractStatementSupport<Revision, RevisionStatement, RevisionEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.REVISION)
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.REVISION)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.REFERENCE)
.build();
- private static final RevisionStatementSupport INSTANCE = new RevisionStatementSupport();
- private RevisionStatementSupport() {
- super(YangStmtMapping.REVISION, StatementPolicy.reject());
- }
-
- public static RevisionStatementSupport getInstance() {
- return INSTANCE;
+ public RevisionStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.REVISION, StatementPolicy.reject(), config);
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
@Beta
public final class RpcStatementSupport extends AbstractSchemaTreeStatementSupport<RpcStatement, RpcEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.RPC)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.INPUT)
- .addOptional(YangStmtMapping.OUTPUT)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .build();
- private static final @NonNull RpcStatementSupport RFC6020_INSTANCE = new RpcStatementSupport(
- InputStatementSupport.rfc6020Instance(), OutputStatementSupport.rfc6020Instance());
- private static final @NonNull RpcStatementSupport RFC7950_INSTANCE = new RpcStatementSupport(
- InputStatementSupport.rfc7950Instance(), OutputStatementSupport.rfc7950Instance());
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.RPC)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.INPUT)
+ .addOptional(YangStmtMapping.OUTPUT)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .build();
private final InputStatementSupport implicitInput;
private final OutputStatementSupport implicitOutput;
- private RpcStatementSupport(final InputStatementSupport implicitInput,
+ public RpcStatementSupport(final YangParserConfiguration config, final InputStatementSupport implicitInput,
final OutputStatementSupport implicitOutput) {
- super(YangStmtMapping.RPC, StatementPolicy.reject());
+ super(YangStmtMapping.RPC, StatementPolicy.reject(), config);
this.implicitInput = requireNonNull(implicitInput);
this.implicitOutput = requireNonNull(implicitOutput);
}
- public static @NonNull RpcStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
- }
-
- public static @NonNull RpcStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
- }
-
@Override
public void onFullDefinitionDeclared(final Mutable<QName, RpcStatement, RpcEffectiveStatement> stmt) {
super.onFullDefinitionDeclared(stmt);
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
extends AbstractStatementSupport<Status, StatusStatement, StatusEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.STATUS).build();
- private static final StatusStatementSupport INSTANCE = new StatusStatementSupport();
- private StatusStatementSupport() {
- super(YangStmtMapping.STATUS, StatementPolicy.contextIndependent());
- }
-
- public static StatusStatementSupport getInstance() {
- return INSTANCE;
+ public StatusStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.STATUS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
.addMandatory(YangStmtMapping.TYPE)
.addOptional(YangStmtMapping.UNITS)
.build();
- private static final TypedefStatementSupport INSTANCE = new TypedefStatementSupport();
- private TypedefStatementSupport() {
- super(YangStmtMapping.TYPEDEF, StatementPolicy.exactReplica());
- }
-
- public static TypedefStatementSupport getInstance() {
- return INSTANCE;
+ public TypedefStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.TYPEDEF, StatementPolicy.exactReplica(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
private static final Splitter SEP_SPLITTER = Splitter.on(CharMatcher.anyOf(" \t\n").precomputed())
.omitEmptyStrings();
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.UNIQUE)
- .build();
- private static final UniqueStatementSupport INSTANCE = new UniqueStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.UNIQUE).build();
- private UniqueStatementSupport() {
+ 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());
- }
-
- public static UniqueStatementSupport getInstance() {
- return INSTANCE;
+ super(YangStmtMapping.UNIQUE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
public final class UnitsStatementSupport
extends AbstractStringStatementSupport<UnitsStatement, UnitsEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.UNITS)
- .build();
- private static final UnitsStatementSupport INSTANCE = new UnitsStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.UNITS).build();
- private UnitsStatementSupport() {
- super(YangStmtMapping.UNITS, StatementPolicy.contextIndependent());
- }
-
- public static UnitsStatementSupport getInstance() {
- return INSTANCE;
+ public UnitsStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.UNITS, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStatementSupport;
public final class ValueStatementSupport
extends AbstractInternedStatementSupport<Integer, ValueStatement, ValueEffectiveStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.VALUE).build();
- private static final ValueStatementSupport INSTANCE = new ValueStatementSupport();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.VALUE).build();
- private ValueStatementSupport() {
- super(YangStmtMapping.VALUE, StatementPolicy.contextIndependent());
- }
-
- public static ValueStatementSupport getInstance() {
- return INSTANCE;
+ public ValueStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.VALUE, StatementPolicy.contextIndependent(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
private final @NonNull XPathSupport xpathSupport;
- private WhenStatementSupport(final 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());
+ super(YangStmtMapping.WHEN, StatementPolicy.contextIndependent(), config);
this.xpathSupport = requireNonNull(xpathSupport);
}
- public static WhenStatementSupport createInstance(final XPathSupport xpathSupport) {
- return new WhenStatementSupport(xpathSupport);
- }
-
@Override
public QualifiedBound parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return xpathSupport.parseXPath(ctx, value);
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
extends AbstractStatementSupport<YangVersion, YangVersionStatement, YangVersionEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.YANG_VERSION).build();
- private static final YangVersionStatementSupport INSTANCE = new YangVersionStatementSupport();
- private YangVersionStatementSupport() {
- super(YangStmtMapping.YANG_VERSION, StatementPolicy.reject());
- }
-
- public static YangVersionStatementSupport getInstance() {
- return INSTANCE;
+ public YangVersionStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.YANG_VERSION, StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport;
extends AbstractBooleanStatementSupport<YinElementStatement, YinElementEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
YangStmtMapping.YIN_ELEMENT).build();
- private static final YinElementStatementSupport INSTANCE = new YinElementStatementSupport();
- private YinElementStatementSupport() {
+ public YinElementStatementSupport(final YangParserConfiguration config) {
super(YangStmtMapping.YIN_ELEMENT,
EffectiveStatements.createYinElement(DeclaredStatements.createYinElement(false)),
EffectiveStatements.createYinElement(DeclaredStatements.createYinElement(true)),
- StatementPolicy.reject());
- }
-
- public static YinElementStatementSupport getInstance() {
- return INSTANCE;
+ StatementPolicy.reject(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@Beta
public final class ModuleStatementSupport
extends AbstractStatementSupport<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> {
- private static final @NonNull ModuleStatementSupport RFC6020_INSTANCE = new ModuleStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.MODULE)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.AUGMENT)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONTACT)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.DEVIATION)
- .addAny(YangStmtMapping.EXTENSION)
- .addAny(YangStmtMapping.FEATURE)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IDENTITY)
- .addAny(YangStmtMapping.IMPORT)
- .addAny(YangStmtMapping.INCLUDE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addMandatory(YangStmtMapping.NAMESPACE)
- .addAny(YangStmtMapping.NOTIFICATION)
- .addOptional(YangStmtMapping.ORGANIZATION)
- .addMandatory(YangStmtMapping.PREFIX)
- .addOptional(YangStmtMapping.REFERENCE)
- .addAny(YangStmtMapping.REVISION)
- .addAny(YangStmtMapping.RPC)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.YANG_VERSION)
- .addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
- .build());
- private static final @NonNull ModuleStatementSupport RFC7950_INSTANCE = new ModuleStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.MODULE)
- .addAny(YangStmtMapping.ANYDATA)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.AUGMENT)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONTACT)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.DEVIATION)
- .addAny(YangStmtMapping.EXTENSION)
- .addAny(YangStmtMapping.FEATURE)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IDENTITY)
- .addAny(YangStmtMapping.IMPORT)
- .addAny(YangStmtMapping.INCLUDE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addMandatory(YangStmtMapping.NAMESPACE)
- .addAny(YangStmtMapping.NOTIFICATION)
- .addOptional(YangStmtMapping.ORGANIZATION)
- .addMandatory(YangStmtMapping.PREFIX)
- .addOptional(YangStmtMapping.REFERENCE)
- .addAny(YangStmtMapping.REVISION)
- .addAny(YangStmtMapping.RPC)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .addMandatory(YangStmtMapping.YANG_VERSION)
- .addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
- .build());
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.MODULE)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.AUGMENT)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONTACT)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.DEVIATION)
+ .addAny(YangStmtMapping.EXTENSION)
+ .addAny(YangStmtMapping.FEATURE)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IDENTITY)
+ .addAny(YangStmtMapping.IMPORT)
+ .addAny(YangStmtMapping.INCLUDE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addMandatory(YangStmtMapping.NAMESPACE)
+ .addAny(YangStmtMapping.NOTIFICATION)
+ .addOptional(YangStmtMapping.ORGANIZATION)
+ .addMandatory(YangStmtMapping.PREFIX)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addAny(YangStmtMapping.REVISION)
+ .addAny(YangStmtMapping.RPC)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.YANG_VERSION)
+ .addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.MODULE)
+ .addAny(YangStmtMapping.ANYDATA)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.AUGMENT)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONTACT)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.DEVIATION)
+ .addAny(YangStmtMapping.EXTENSION)
+ .addAny(YangStmtMapping.FEATURE)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IDENTITY)
+ .addAny(YangStmtMapping.IMPORT)
+ .addAny(YangStmtMapping.INCLUDE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addMandatory(YangStmtMapping.NAMESPACE)
+ .addAny(YangStmtMapping.NOTIFICATION)
+ .addOptional(YangStmtMapping.ORGANIZATION)
+ .addMandatory(YangStmtMapping.PREFIX)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addAny(YangStmtMapping.REVISION)
+ .addAny(YangStmtMapping.RPC)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .addMandatory(YangStmtMapping.YANG_VERSION)
+ .addOptional(OpenConfigStatements.OPENCONFIG_VERSION)
+ .build();
private final SubstatementValidator validator;
- private ModuleStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.MODULE, StatementPolicy.reject());
+ private ModuleStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.MODULE, StatementPolicy.reject(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull ModuleStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull ModuleStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new ModuleStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull ModuleStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull ModuleStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new ModuleStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins;
abstract class AbstractNotificationStatementSupport
extends AbstractSchemaTreeStatementSupport<NotificationStatement, NotificationEffectiveStatement> {
- AbstractNotificationStatementSupport() {
- super(YangStmtMapping.NOTIFICATION, uninstantiatedPolicy());
+ AbstractNotificationStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.NOTIFICATION, uninstantiatedPolicy(), config);
}
@Override
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class NotificationStatementRFC6020Support extends AbstractNotificationStatementSupport {
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
.build();
- private static final NotificationStatementRFC6020Support INSTANCE = new NotificationStatementRFC6020Support();
- private NotificationStatementRFC6020Support() {
- // Hidden
- }
-
- public static NotificationStatementRFC6020Support getInstance() {
- return INSTANCE;
+ public NotificationStatementRFC6020Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
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;
*/
@Beta
public final class NotificationStatementRFC7950Support extends AbstractNotificationStatementSupport {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .NOTIFICATION)
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.NOTIFICATION)
.addAny(YangStmtMapping.ANYDATA)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.CHOICE)
.addAny(YangStmtMapping.USES)
.build();
- private static final ImmutableSet<StatementDefinition> ILLEGAL_PARENTS = ImmutableSet.of(
- YangStmtMapping.NOTIFICATION, YangStmtMapping.RPC, YangStmtMapping.ACTION);
- private static final NotificationStatementRFC7950Support INSTANCE = new NotificationStatementRFC7950Support();
+ private static final ImmutableSet<StatementDefinition> ILLEGAL_PARENTS =
+ ImmutableSet.of(YangStmtMapping.NOTIFICATION, YangStmtMapping.RPC, YangStmtMapping.ACTION);
- private NotificationStatementRFC7950Support() {
- // Hidden
- }
-
- public static NotificationStatementRFC7950Support getInstance() {
- return INSTANCE;
+ public NotificationStatementRFC7950Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
extends AbstractStatementSupport<PathExpression, PathStatement, PathEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
YangStmtMapping.PATH).build();
- private static final PathStatementSupport LENIENT_INSTANCE = new PathStatementSupport(
- new PathExpressionParser.Lenient());
- private static final PathStatementSupport STRICT_INSTANCE = new PathStatementSupport(
- new PathExpressionParser());
private final PathExpressionParser parser;
- private PathStatementSupport(final PathExpressionParser parser) {
+ private PathStatementSupport(final YangParserConfiguration config, final PathExpressionParser parser) {
// TODO: can 'path' really be copied?
- super(YangStmtMapping.PATH, StatementPolicy.contextIndependent());
+ super(YangStmtMapping.PATH, StatementPolicy.contextIndependent(), config);
this.parser = requireNonNull(parser);
}
- public static PathStatementSupport lenientInstance() {
- return LENIENT_INSTANCE;
+ public static PathStatementSupport lenientInstance(final YangParserConfiguration config) {
+ return new PathStatementSupport(config, new PathExpressionParser.Lenient());
}
- public static PathStatementSupport strictInstance() {
- return STRICT_INSTANCE;
+ public static PathStatementSupport strictInstance(final YangParserConfiguration config) {
+ return new PathStatementSupport(config, new PathExpressionParser());
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PatternExpression;
import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
@Beta
public final class PatternStatementSupport
extends AbstractStatementSupport<PatternExpression, PatternStatement, PatternEffectiveStatement> {
- private static final @NonNull PatternStatementSupport RFC6020_INSTANCE = new PatternStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.PATTERN)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.ERROR_APP_TAG)
.addOptional(YangStmtMapping.ERROR_MESSAGE)
.addOptional(YangStmtMapping.REFERENCE)
- .build());
- private static final @NonNull PatternStatementSupport RFC7950_INSTANCE = new PatternStatementSupport(
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.PATTERN)
.addOptional(YangStmtMapping.DESCRIPTION)
.addOptional(YangStmtMapping.ERROR_APP_TAG)
.addOptional(YangStmtMapping.ERROR_MESSAGE)
.addOptional(YangStmtMapping.MODIFIER)
.addOptional(YangStmtMapping.REFERENCE)
- .build());
+ .build();
private final SubstatementValidator validator;
- private PatternStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.PATTERN, StatementPolicy.contextIndependent());
+ private PatternStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.PATTERN, StatementPolicy.contextIndependent(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull PatternStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull PatternStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new PatternStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull PatternStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull PatternStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new PatternStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
@Beta
public final class RefineStatementSupport
extends AbstractStatementSupport<Descendant, RefineStatement, RefineEffectiveStatement> {
- private static final @NonNull RefineStatementSupport RFC6020_INSTANCE = new RefineStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.REFINE)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.MANDATORY)
- .addOptional(YangStmtMapping.PRESENCE)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .build());
- private static final @NonNull RefineStatementSupport RFC7950_INSTANCE = new RefineStatementSupport(
- SubstatementValidator.builder(YangStmtMapping.REFINE)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.CONFIG)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addOptional(YangStmtMapping.PRESENCE)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .build());
+ private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.REFINE)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addOptional(YangStmtMapping.PRESENCE)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.REFINE)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addOptional(YangStmtMapping.PRESENCE)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .build();
private final SubstatementValidator validator;
- private RefineStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.REFINE, StatementPolicy.reject());
+ private RefineStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.REFINE, StatementPolicy.reject(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull RefineStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull RefineStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new RefineStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull RefineStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull RefineStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new RefineStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
@Beta
public final class SubmoduleStatementSupport
extends AbstractStatementSupport<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> {
- private static final @NonNull SubmoduleStatementSupport RFC6020_INSTANCE = new SubmoduleStatementSupport(
+ private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.SUBMODULE)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.AUGMENT)
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.YANG_VERSION)
- .build());
- private static final @NonNull SubmoduleStatementSupport RFC7950_INSTANCE = new SubmoduleStatementSupport(
+ .build();
+ private static final SubstatementValidator RFC7950_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.SUBMODULE)
.addAny(YangStmtMapping.ANYDATA)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.TYPEDEF)
.addAny(YangStmtMapping.USES)
.addOptional(YangStmtMapping.YANG_VERSION)
- .build());
+ .build();
private final SubstatementValidator validator;
- private SubmoduleStatementSupport(final SubstatementValidator validator) {
- super(YangStmtMapping.SUBMODULE, StatementPolicy.reject());
+ private SubmoduleStatementSupport(final YangParserConfiguration config, final SubstatementValidator validator) {
+ super(YangStmtMapping.SUBMODULE, StatementPolicy.reject(), config);
this.validator = requireNonNull(validator);
}
- public static @NonNull SubmoduleStatementSupport rfc6020Instance() {
- return RFC6020_INSTANCE;
+ public static @NonNull SubmoduleStatementSupport rfc6020Instance(final YangParserConfiguration config) {
+ return new SubmoduleStatementSupport(config, RFC6020_VALIDATOR);
}
- public static @NonNull SubmoduleStatementSupport rfc7950Instance() {
- return RFC7950_INSTANCE;
+ public static @NonNull SubmoduleStatementSupport rfc7950Instance(final YangParserConfiguration config) {
+ return new SubmoduleStatementSupport(config, RFC7950_VALIDATOR);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.IdentityRefSpecification;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.IdentityrefTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
abstract class AbstractIdentityRefSpecificationSupport
extends AbstractTypeSupport<IdentityRefSpecification> {
+ AbstractIdentityRefSpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
+
@Override
public final void onFullDefinitionDeclared(final Mutable<QName, IdentityRefSpecification,
EffectiveStatement<QName, IdentityRefSpecification>> stmt) {
import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpecification;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.LeafrefTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
abstract class AbstractLeafrefSpecificationSupport extends AbstractTypeSupport<LeafrefSpecification> {
+ AbstractLeafrefSpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
+
@Override
protected final LeafrefSpecification createDeclared(final StmtContext<QName, LeafrefSpecification, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
import java.math.BigDecimal;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.type.BitsTypeBuilder;
import org.opendaylight.yangtools.yang.model.ri.type.EnumerationTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
abstract class AbstractTypeStatementSupport extends AbstractTypeSupport<TypeStatement> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.BASE)
- .addAny(YangStmtMapping.BIT)
- .addAny(YangStmtMapping.ENUM)
- .addOptional(YangStmtMapping.FRACTION_DIGITS)
- .addOptional(YangStmtMapping.LENGTH)
- .addOptional(YangStmtMapping.PATH)
- .addAny(YangStmtMapping.PATTERN)
- .addOptional(YangStmtMapping.RANGE)
- .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
- .addAny(YangStmtMapping.TYPE)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.BASE)
+ .addAny(YangStmtMapping.BIT)
+ .addAny(YangStmtMapping.ENUM)
+ .addOptional(YangStmtMapping.FRACTION_DIGITS)
+ .addOptional(YangStmtMapping.LENGTH)
+ .addOptional(YangStmtMapping.PATH)
+ .addAny(YangStmtMapping.PATTERN)
+ .addOptional(YangStmtMapping.RANGE)
+ .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
+ .addAny(YangStmtMapping.TYPE)
+ .build();
private static final ImmutableMap<String, BuiltinEffectiveStatement> STATIC_BUILT_IN_TYPES =
ImmutableMap.<String, BuiltinEffectiveStatement>builder()
.put(TypeDefinitions.UINT64.getLocalName(), BuiltinEffectiveStatement.UINT64)
.build();
- private static final ImmutableMap<String, StatementSupport<?, ?, ?>> DYNAMIC_BUILT_IN_TYPES =
- ImmutableMap.<String, StatementSupport<?, ?, ?>>builder()
- .put(TypeDefinitions.BITS.getLocalName(), new BitsSpecificationSupport())
- .put(TypeDefinitions.DECIMAL64.getLocalName(), new Decimal64SpecificationSupport())
- .put(TypeDefinitions.ENUMERATION.getLocalName(), new EnumSpecificationSupport())
- .put(TypeDefinitions.IDENTITYREF.getLocalName(), new IdentityRefSpecificationRFC6020Support())
- .put(TypeDefinitions.INSTANCE_IDENTIFIER.getLocalName(), new InstanceIdentifierSpecificationSupport())
- .put(TypeDefinitions.LEAFREF.getLocalName(), new LeafrefSpecificationRFC6020Support())
- .put(TypeDefinitions.UNION.getLocalName(), new UnionSpecificationSupport())
+ private final ImmutableMap<String, StatementSupport<?, ?, ?>> dynamicBuiltInTypes;
+
+ AbstractTypeStatementSupport(final YangParserConfiguration config) {
+ super(config);
+ 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.INSTANCE_IDENTIFIER.getLocalName(), new InstanceIdentifierSpecificationSupport(config))
+ .put(TypeDefinitions.LEAFREF.getLocalName(), new LeafrefSpecificationRFC6020Support(config))
+ .put(TypeDefinitions.UNION.getLocalName(), new UnionSpecificationSupport(config))
.build();
-
- private static final ImmutableMap<String, String> BUILT_IN_TYPES = Maps.uniqueIndex(ImmutableSet.copyOf(
- Iterables.<String>concat(STATIC_BUILT_IN_TYPES.keySet(), DYNAMIC_BUILT_IN_TYPES.keySet())), key -> key);
+ }
@Override
public final void onFullDefinitionDeclared(
@Override
public boolean hasArgumentSpecificSupports() {
- return !DYNAMIC_BUILT_IN_TYPES.isEmpty();
+ return !dynamicBuiltInTypes.isEmpty();
}
@Override
public StatementSupport<?, ?, ?> getSupportSpecificForArgument(final String argument) {
- return DYNAMIC_BUILT_IN_TYPES.get(argument);
+ return dynamicBuiltInTypes.get(argument);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.api.type.TypeDefinitions;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
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;
TypeDefinitions.UNION),
QName::getLocalName);
- AbstractTypeSupport() {
- super(YangStmtMapping.TYPE, StatementPolicy.exactReplica());
+ AbstractTypeSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.TYPE, StatementPolicy.exactReplica(), config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.BitEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.BitsSpecification;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.BitsTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
final class BitsSpecificationSupport extends AbstractTypeSupport<BitsSpecification> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.TYPE)
- .addMultiple(YangStmtMapping.BIT)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.BIT).build();
+
+ BitsSpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.DecimalTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
final class Decimal64SpecificationSupport extends AbstractTypeSupport<Decimal64Specification> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.TYPE)
- .addMandatory(YangStmtMapping.FRACTION_DIGITS)
- .addOptional(YangStmtMapping.RANGE)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE)
+ .addMandatory(YangStmtMapping.FRACTION_DIGITS)
+ .addOptional(YangStmtMapping.RANGE)
+ .build();
+
+ Decimal64SpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.EnumSpecification;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.EnumerationTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.ENUM).build();
+ EnumSpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
+
@Override
protected SubstatementValidator getSubstatementValidator() {
return SUBSTATEMENT_VALIDATOR;
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.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();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMandatory(YangStmtMapping.BASE).build();
+
+ IdentityRefSpecificationRFC6020Support(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.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();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.BASE).build();
+
+ IdentityRefSpecificationRFC7950Support(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.InstanceIdentifierSpecification;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.InstanceIdentifierTypeBuilder;
import org.opendaylight.yangtools.yang.model.ri.type.RestrictedTypes;
final class InstanceIdentifierSpecificationSupport
extends AbstractTypeSupport<InstanceIdentifierSpecification> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
- .build();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addOptional(YangStmtMapping.REQUIRE_INSTANCE).build();
+
+ InstanceIdentifierSpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.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();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMandatory(YangStmtMapping.PATH).build();
+
+ LeafrefSpecificationRFC6020Support(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.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)
+ 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 org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
public final class TypeStatementRFC6020Support extends AbstractTypeStatementSupport {
- private static final TypeStatementRFC6020Support INSTANCE = new TypeStatementRFC6020Support();
-
- private TypeStatementRFC6020Support() {
- // Hidden
- }
-
- public static TypeStatementRFC6020Support getInstance() {
- return INSTANCE;
+ public TypeStatementRFC6020Support(final YangParserConfiguration config) {
+ super(config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
import org.opendaylight.yangtools.yang.model.api.type.TypeDefinitions;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
*/
@Beta
public final class TypeStatementRFC7950Support extends AbstractTypeStatementSupport {
- private static final ImmutableMap<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS = ImmutableMap.of(
- TypeDefinitions.LEAFREF.getLocalName(), new LeafrefSpecificationRFC7950Support(),
- TypeDefinitions.IDENTITYREF.getLocalName(), new IdentityRefSpecificationRFC7950Support());
- private static final TypeStatementRFC7950Support INSTANCE = new TypeStatementRFC7950Support();
+ private final ImmutableMap<String, StatementSupport<?, ?, ?>> argumentSpecificSupports;
- private TypeStatementRFC7950Support() {
- // Hidden
- }
-
- public static TypeStatementRFC7950Support getInstance() {
- return INSTANCE;
+ public TypeStatementRFC7950Support(final YangParserConfiguration config) {
+ super(config);
+ argumentSpecificSupports = ImmutableMap.of(
+ TypeDefinitions.LEAFREF.getLocalName(), new LeafrefSpecificationRFC7950Support(config),
+ TypeDefinitions.IDENTITYREF.getLocalName(), new IdentityRefSpecificationRFC7950Support(config));
}
@Override
public boolean hasArgumentSpecificSupports() {
- return !ARGUMENT_SPECIFIC_SUPPORTS.isEmpty() || super.hasArgumentSpecificSupports();
+ return !argumentSpecificSupports.isEmpty() || super.hasArgumentSpecificSupports();
}
@Override
public StatementSupport<?, ?, ?> getSupportSpecificForArgument(final String argument) {
- final StatementSupport<?, ?, ?> potential = ARGUMENT_SPECIFIC_SUPPORTS.get(argument);
+ final StatementSupport<?, ?, ?> potential = argumentSpecificSupports.get(argument);
return potential != null ? potential : super.getSupportSpecificForArgument(argument);
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.UnionSpecification;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.ri.type.UnionTypeBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
final class UnionSpecificationSupport extends AbstractTypeSupport<UnionSpecification> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.TYPE)
- .addMultiple(YangStmtMapping.TYPE)
- .build();
+ SubstatementValidator.builder(YangStmtMapping.TYPE).addMultiple(YangStmtMapping.TYPE).build();
+
+ UnionSpecificationSupport(final YangParserConfiguration config) {
+ super(config);
+ }
@Override
protected SubstatementValidator getSubstatementValidator() {
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles;
.addOptional(YangStmtMapping.STATUS)
.addOptional(YangStmtMapping.WHEN)
.build();
- private static final UsesStatementSupport INSTANCE = new UsesStatementSupport();
- private UsesStatementSupport() {
- super(YangStmtMapping.USES, StatementPolicy.exactReplica());
- }
-
- public static UsesStatementSupport getInstance() {
- return INSTANCE;
+ public UsesStatementSupport(final YangParserConfiguration config) {
+ super(YangStmtMapping.USES, StatementPolicy.exactReplica(), config);
}
@Override
+++ /dev/null
-/*
- * Copyright (c) 2016 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.thirdparty.plugin;
-
-import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-
-public final class CustomInferencePipeline {
- public static final CrossSourceStatementReactor CUSTOM_REACTOR = RFC7950Reactors.defaultReactorBuilder()
- .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ThirdPartyExtensionSupport.getInstance())
- .addNamespaceSupport(ModelProcessingPhase.FULL_DECLARATION, ThirdPartyNamespace.BEHAVIOR)
- .build();
-
- private CustomInferencePipeline() {
- // Hidden on purpose
- }
-}
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
+import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.stmt.StmtTestUtils;
public class ThirdPartyExtensionPluginTest {
@Test
public void test() throws URISyntaxException, ReactorException, IOException, YangSyntaxErrorException {
- final CrossSourceStatementReactor.BuildAction reactor = CustomInferencePipeline.CUSTOM_REACTOR.newBuild();
+ final BuildAction reactor = RFC7950Reactors.defaultReactorBuilder()
+ .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
+ new ThirdPartyExtensionSupport(YangParserConfiguration.DEFAULT))
+ .addNamespaceSupport(ModelProcessingPhase.FULL_DECLARATION, ThirdPartyNamespace.BEHAVIOR)
+ .build()
+ .newBuild();
reactor.addSource(StmtTestUtils.sourceForResource("/plugin-test/foo.yang"));
final SchemaContext schema = reactor.buildEffective();
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;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public final class ThirdPartyExtensionSupport
extends AbstractStringStatementSupport<ThirdPartyExtensionStatement, ThirdPartyExtensionEffectiveStatement> {
- private static final ThirdPartyExtensionSupport INSTANCE = new ThirdPartyExtensionSupport();
-
- private ThirdPartyExtensionSupport() {
- super(ThirdPartyExtensionsMapping.THIRD_PARTY_EXTENSION, StatementPolicy.contextIndependent());
- }
-
- public static ThirdPartyExtensionSupport getInstance() {
- return INSTANCE;
+ public ThirdPartyExtensionSupport(final YangParserConfiguration config) {
+ super(ThirdPartyExtensionsMapping.THIRD_PARTY_EXTENSION, StatementPolicy.contextIndependent(), config);
}
@Override
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-repo-api</artifactId>
requires transitive org.opendaylight.yangtools.concepts;
requires transitive org.opendaylight.yangtools.yang.common;
requires transitive org.opendaylight.yangtools.yang.model.api;
+ requires transitive org.opendaylight.yangtools.yang.parser.api;
requires transitive org.opendaylight.yangtools.yang.repo.api;
requires org.slf4j;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
private final @NonNull D emptyDeclaredTrue;
protected AbstractBooleanStatementSupport(final StatementDefinition publicDefinition,
- final E emptyEffectiveFalse, final E emptyEffectiveTrue, final StatementPolicy<Boolean, D> policy) {
- super(publicDefinition, policy);
+ final E emptyEffectiveFalse, final E emptyEffectiveTrue, final StatementPolicy<Boolean, D> policy,
+ final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
this.emptyEffectiveFalse = requireNonNull(emptyEffectiveFalse);
this.emptyEffectiveTrue = requireNonNull(emptyEffectiveTrue);
emptyDeclaredFalse = requireNonNull(emptyEffectiveFalse.getDeclared());
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
@Beta
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) {
- super(publicDefinition, policy);
+ final StatementPolicy<Empty, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
/**
});
protected AbstractInternedStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<A, D> policy) {
- super(publicDefinition, policy);
+ final StatementPolicy<A, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
/**
* A specialization of {@link AbstractInternedStatementSupport} for {@link String} arguments.
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) {
- super(publicDefinition, policy);
+ final StatementPolicy<String, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
/**
* Specialization of {@link AbstractStatementSupport} for QName statement arguments.
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) {
- super(publicDefinition, policy);
+ final StatementPolicy<QName, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
StatementPolicy.copyDeclared(new SchemaTreeEquality<>());
protected AbstractSchemaTreeStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<QName, D> policy) {
- super(publicDefinition, policy);
+ final StatementPolicy<QName, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
/**
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+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.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
/**
@Beta
public abstract class AbstractStatementSupport<A, D extends DeclaredStatement<A>,
E extends EffectiveStatement<A, D>> extends StatementSupport<A, D, E> {
- protected AbstractStatementSupport(final StatementDefinition publicDefinition, final StatementPolicy<A, D> policy) {
+ private final boolean retainDeclarationReference;
+
+ protected AbstractStatementSupport(final StatementDefinition publicDefinition, final StatementPolicy<A, D> policy,
+ final YangParserConfiguration config) {
super(publicDefinition, policy);
+ this.retainDeclarationReference = config.retainDeclarationReferences();
}
@Override
public final D createDeclared(final StmtContext<A, D, ?> ctx) {
- return createDeclared(ctx, ctx.declaredSubstatements().stream()
+ final D stmt = createDeclared(ctx, ctx.declaredSubstatements().stream()
.map(StmtContext::declared)
.collect(ImmutableList.toImmutableList()));
+ return retainDeclarationReference ? attachDeclarationReference(stmt, ctx) : stmt;
}
protected abstract @NonNull D createDeclared(@NonNull StmtContext<A, D, ?> ctx,
@NonNull ImmutableList<? extends DeclaredStatement<?>> substatements);
+ private @NonNull D attachDeclarationReference(final @NonNull D stmt, final @NonNull StmtContext<A, D, ?> ctx) {
+ final DeclarationReference ref = ctx.sourceReference().declarationReference();
+ return ref == null ? stmt : attachDeclarationReference(stmt, ref);
+ }
+
+ /**
+ * Attach specified {@link DeclarationReference} to a baseline declared statement. If an implementation does not
+ * support attaching DeclarationReferences, it should return the statement unchanged.
+ *
+ * @param stmt Declared statement
+ * @param reference {@link DeclarationReference} to attach
+ * @return Equivalent of stmt, potentially with specified reference attached.
+ */
+ // FIXME: make this method abstract
+ protected @NonNull D attachDeclarationReference(final @NonNull D stmt,
+ final @NonNull DeclarationReference reference) {
+ return stmt;
+ }
+
@Override
public final E createEffective(final Current<A, D> stmt,
final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserConfiguration;
/**
* Specialization of {@link AbstractStatementSupport} for String statement arguments. Note this (mostly) implies
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) {
- super(publicDefinition, policy);
+ final StatementPolicy<String, D> policy, final YangParserConfiguration config) {
+ super(publicDefinition, policy, config);
}
@Override
Code Review / yangtools.git / commitdiff