import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
/**
* An {@link InferenceAction} tasked with identifying when we are dealing with {@link YangDataConstants#RFC8040_SOURCE}.
// Check namespace and revision first
final QNameModule moduleQName =
- moduleCtx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, moduleCtx);
+ moduleCtx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, moduleCtx);
if (!YangDataConstants.RFC8040_MODULE.equals(moduleQName)) {
return;
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedNamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundles;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundles.ValidationBundleType;
}
void setSupportedFeatures(final Set<QName> supportedFeatures) {
- addToNamespace(SourceParserNamespaces.SUPPORTED_FEATURES, Empty.value(),
- ImmutableSet.copyOf(supportedFeatures));
+ addToNamespace(ParserNamespaces.SUPPORTED_FEATURES, Empty.value(), ImmutableSet.copyOf(supportedFeatures));
}
void setModulesDeviatedByModules(final SetMultimap<QNameModule, QNameModule> modulesDeviatedByModules) {
- addToNamespace(SourceParserNamespaces.MODULES_DEVIATED_BY, Empty.value(),
+ addToNamespace(ParserNamespaces.MODULES_DEVIATED_BY, Empty.value(),
ImmutableSetMultimap.copyOf(modulesDeviatedByModules));
}
}
private static SourceIdentifier createSourceIdentifier(final StmtContext<?, ?, ?> root) {
- final QNameModule qNameModule = root.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, root);
+ final QNameModule qNameModule = root.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, root);
final Object arg = root.getArgument();
verify(arg instanceof Unqualified, "Unexpected argument %s", arg);
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStatementState;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
if (isParentSupportedByFeatures()) {
// If the set of supported features has not been provided, all features are supported by default.
- final Set<QName> supportedFeatures = getFromNamespace(SourceParserNamespaces.SUPPORTED_FEATURES,
+ final Set<QName> supportedFeatures = getFromNamespace(ParserNamespaces.SUPPORTED_FEATURES,
Empty.value());
if (supportedFeatures == null || StmtContextUtils.checkFeatureSupport(this, supportedFeatures)) {
flags |= SET_SUPPORTED_BY_FEATURES;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.RootStmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public <K, V> V putToLocalStorage(final ParserNamespace<K, V> type, final K key, final V value) {
- if (SourceParserNamespaces.INCLUDED_MODULE.equals(type)) {
+ if (ParserNamespaces.INCLUDED_MODULE.equals(type)) {
if (includedContexts.isEmpty()) {
includedContexts = new ArrayList<>(1);
}
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinitionMap;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.slf4j.Logger;
}
private void updateImportedNamespaces(final ParserNamespace<?, ?> type, final Object value) {
- if (SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX.equals(type)
- || SourceParserNamespaces.IMPORTED_MODULE.equals(type)) {
+ if (ParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX.equals(type)
+ || ParserNamespaces.IMPORTED_MODULE.equals(type)) {
verify(value instanceof RootStatementContext, "Unexpected imported value %s", value);
if (importedNamespaces.isEmpty()) {
private PrefixResolver preLinkagePrefixes() {
final HashMapPrefixResolver preLinkagePrefixes = new HashMapPrefixResolver();
- final var prefixToNamespaceMap = getAllFromLocalStorage(SourceParserNamespaces.IMP_PREFIX_TO_NAMESPACE);
+ final var prefixToNamespaceMap = getAllFromLocalStorage(ParserNamespaces.IMP_PREFIX_TO_NAMESPACE);
if (prefixToNamespaceMap == null) {
//:FIXME if it is a submodule without any import, the map is null. Handle also submodules and includes...
return null;
}
private PrefixResolver prefixes() {
- final var allImports = root.getAllFromNamespace(SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX);
+ final var allImports = root.getAllFromNamespace(ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX);
if (allImports != null) {
allImports.forEach((key, value) ->
- prefixToModuleMap.put(key, root.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, value)));
+ prefixToModuleMap.put(key, root.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, value)));
}
- final var allBelongsTo = root.getAllFromNamespace(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX);
+ final var allBelongsTo = root.getAllFromNamespace(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX);
if (allBelongsTo != null) {
allBelongsTo.forEach((key, value) ->
- prefixToModuleMap.put(key, root.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, value)));
+ prefixToModuleMap.put(key, root.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, value)));
}
return prefixToModuleMap;
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.namespace;
-import static org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME;
-import static org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX;
-import static org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces.MODULECTX_TO_QNAME;
-import static org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces.MODULE_NAME_TO_QNAME;
-
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
import java.util.HashMap;
import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
// Additional mappings
final Map<String, QNameModule> additional = new HashMap<>();
- final Map<String, StmtContext<?, ?, ?>> imports = ctx.getAllFromNamespace(IMPORT_PREFIX_TO_MODULECTX);
+ final Map<String, StmtContext<?, ?, ?>> imports = ctx.getAllFromNamespace(
+ ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX);
if (imports != null) {
for (Entry<String, StmtContext<?, ?, ?>> entry : imports.entrySet()) {
if (!moduleToPrefix.containsValue(entry.getKey())) {
- QNameModule qnameModule = ctx.getFromNamespace(MODULECTX_TO_QNAME, entry.getValue());
+ QNameModule qnameModule = ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME,
+ entry.getValue());
if (qnameModule == null && ctx.producesDeclared(SubmoduleStatement.class)) {
- qnameModule = ctx.getFromNamespace(MODULE_NAME_TO_QNAME,
- ctx.getFromNamespace(BELONGSTO_PREFIX_TO_MODULE_NAME, entry.getKey()));
+ qnameModule = ctx.getFromNamespace(ParserNamespaces.MODULE_NAME_TO_QNAME,
+ ctx.getFromNamespace(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME, entry.getKey()));
}
if (qnameModule != null) {
}
}
if (ctx.producesDeclared(SubmoduleStatement.class)) {
- final Map<String, Unqualified> belongsTo = ctx.getAllFromNamespace(BELONGSTO_PREFIX_TO_MODULE_NAME);
+ final Map<String, Unqualified> belongsTo = ctx.getAllFromNamespace(
+ ParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME);
if (belongsTo != null) {
for (Entry<String, Unqualified> entry : belongsTo.entrySet()) {
- final QNameModule module = ctx.getFromNamespace(MODULE_NAME_TO_QNAME, entry.getValue());
+ final QNameModule module = ctx.getFromNamespace(ParserNamespaces.MODULE_NAME_TO_QNAME,
+ entry.getValue());
if (module != null && !additional.containsKey(entry.getKey())) {
additional.put(entry.getKey(), module);
}
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementDefinitions;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupportBundle;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceNamespaceBehaviours;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundles;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundles.ValidationBundleType;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
private static final StatementSupportBundle INIT_BUNDLE = StatementSupportBundle.builder(SUPPORTED_VERSIONS)
.addSupport(ValidationBundles.BEHAVIOUR)
- .addSupport(SourceNamespaceBehaviours.SUPPORTED_FEATURES)
- .addSupport(SourceNamespaceBehaviours.MODULES_DEVIATED_BY)
+ .addSupport(NamespaceBehaviours.SUPPORTED_FEATURES)
+ .addSupport(NamespaceBehaviours.MODULES_DEVIATED_BY)
.build();
private RFC7950Reactors() {
.addSupport(new YangVersionStatementSupport(config))
.addSupport(new RevisionStatementSupport(config))
.addSupport(new RevisionDateStatementSupport(config))
- .addSupport(SourceNamespaceBehaviours.MODULE_NAME_TO_NAMESPACE)
+ .addSupport(NamespaceBehaviours.MODULE_NAME_TO_NAMESPACE)
.addSupport(NamespaceBehaviours.PRELINKAGE_MODULE)
- .addSupport(SourceNamespaceBehaviours.IMP_PREFIX_TO_NAMESPACE)
- .addSupport(SourceNamespaceBehaviours.MODULECTX_TO_QNAME)
+ .addSupport(NamespaceBehaviours.IMP_PREFIX_TO_NAMESPACE)
+ .addSupport(NamespaceBehaviours.MODULECTX_TO_QNAME)
.addSupport(QNameModuleNamespace.BEHAVIOUR)
.addSupport(ImportedVersionNamespace.BEHAVIOUR)
.build();
.addSupport(new ContactStatementSupport(config))
.addSupport(new OrganizationStatementSupport(config))
.addSupport(NamespaceBehaviours.MODULE)
- .addSupport(SourceNamespaceBehaviours.MODULE_FOR_BELONGSTO)
+ .addSupport(NamespaceBehaviours.MODULE_FOR_BELONGSTO)
.addSupport(NamespaceBehaviours.SUBMODULE)
.addSupport(NamespaceBehaviours.NAMESPACE_TO_MODULE)
- .addSupport(SourceNamespaceBehaviours.MODULE_NAME_TO_QNAME)
- .addSupport(SourceNamespaceBehaviours.MODULECTX_TO_SOURCE)
- .addSupport(SourceNamespaceBehaviours.MODULE_NAMESPACE_TO_NAME)
- .addSupport(SourceNamespaceBehaviours.PREFIX_TO_MODULE)
- .addSupport(SourceNamespaceBehaviours.IMPORTED_MODULE)
- .addSupport(SourceNamespaceBehaviours.INCLUDED_MODULE)
- .addSupport(SourceNamespaceBehaviours.INCLUDED_SUBMODULE_NAME_TO_MODULECTX)
- .addSupport(SourceNamespaceBehaviours.IMPORT_PREFIX_TO_MODULECTX)
- .addSupport(SourceNamespaceBehaviours.BELONGSTO_PREFIX_TO_MODULECTX)
+ .addSupport(NamespaceBehaviours.MODULE_NAME_TO_QNAME)
+ .addSupport(NamespaceBehaviours.MODULECTX_TO_SOURCE)
+ .addSupport(NamespaceBehaviours.MODULE_NAMESPACE_TO_NAME)
+ .addSupport(NamespaceBehaviours.PREFIX_TO_MODULE)
+ .addSupport(NamespaceBehaviours.IMPORTED_MODULE)
+ .addSupport(NamespaceBehaviours.INCLUDED_MODULE)
+ .addSupport(NamespaceBehaviours.INCLUDED_SUBMODULE_NAME_TO_MODULECTX)
+ .addSupport(NamespaceBehaviours.IMPORT_PREFIX_TO_MODULECTX)
+ .addSupport(NamespaceBehaviours.BELONGSTO_PREFIX_TO_MODULECTX)
.addSupport(ModuleQNameToPrefix.BEHAVIOUR)
- .addSupport(SourceNamespaceBehaviours.BELONGSTO_PREFIX_TO_MODULE_NAME)
+ .addSupport(NamespaceBehaviours.BELONGSTO_PREFIX_TO_MODULE_NAME)
.build();
}
import org.opendaylight.yangtools.yang.model.api.stmt.compat.NotificationNodeContainerCompat;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithTypedefNamespace;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.DocumentedNodeMixin;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
@Beta
public abstract class AbstractEffectiveModule<D extends DeclaredStatement<Unqualified>,
streamEffectiveSubstatements(ImportEffectiveStatement.class)
.map(imp -> imp.findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class).get())
.forEach(pfx -> {
- final StmtContext<?, ?, ?> importedCtx =
- verifyNotNull(stmt.getFromNamespace(SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, pfx),
- "Failed to resolve prefix %s", pfx);
+ final var importedCtx =
+ verifyNotNull(stmt.getFromNamespace(ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, pfx),
+ "Failed to resolve prefix %s", pfx);
builder.put(pfx, (ModuleEffectiveStatement) importedCtx.buildEffective());
});
}
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.BoundStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final Mutable<DeviateKind, DeviateStatement, DeviateEffectiveStatement> deviateStmtCtx,
final SchemaNodeIdentifier deviationTarget) {
final SetMultimap<QNameModule, QNameModule> modulesDeviatedByModules = deviateStmtCtx.getFromNamespace(
- SourceParserNamespaces.MODULES_DEVIATED_BY, Empty.value());
+ ParserNamespaces.MODULES_DEVIATED_BY, Empty.value());
if (modulesDeviatedByModules == null) {
return true;
}
- final QNameModule currentModule = deviateStmtCtx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME,
+ final QNameModule currentModule = deviateStmtCtx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME,
deviateStmtCtx.getRoot());
final QNameModule targetModule = Iterables.getLast(deviationTarget.getNodeIdentifiers()).getModule();
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.source.YangVersionLinkageException;
@Beta
final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
verify(moduleName.equals(importedModuleContext.getArgument()));
final XMLNamespace importedModuleNamespace = verifyNotNull(importedModuleContext.getFromNamespace(
- SourceParserNamespaces.MODULE_NAME_TO_NAMESPACE, moduleName));
+ ParserNamespaces.MODULE_NAME_TO_NAMESPACE, moduleName));
final String impPrefix = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class), stmt,
"Missing prefix statement");
}
}
- stmt.addToNs(SourceParserNamespaces.IMP_PREFIX_TO_NAMESPACE, impPrefix, importedModuleNamespace);
+ stmt.addToNs(ParserNamespaces.IMP_PREFIX_TO_NAMESPACE, impPrefix, importedModuleNamespace);
}
@Override
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
final class RevisionImport {
private RevisionImport() {
final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
final SourceIdentifier importedModuleIdentifier = stmt.getFromNamespace(
- SourceParserNamespaces.MODULECTX_TO_SOURCE, importedModule);
+ ParserNamespaces.MODULECTX_TO_SOURCE, importedModule);
stmt.addToNs(ImportedVersionNamespace.INSTANCE, Empty.value(), importedModuleIdentifier);
final QNameModule mod = InferenceException.throwIfNull(
- stmt.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, importedModule), stmt,
+ stmt.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, importedModule), stmt,
"Failed to find module of %s", importedModule);
- linkageTarget.resolve(ctx).addToNs(SourceParserNamespaces.IMPORTED_MODULE, importedModuleIdentifier,
+ linkageTarget.resolve(ctx).addToNs(ParserNamespaces.IMPORTED_MODULE, importedModuleIdentifier,
importedModule);
final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
- stmt.addToNs(SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, impPrefix, importedModule);
+ stmt.addToNs(ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, impPrefix, importedModule);
stmt.addToNs(ModuleQNameToPrefix.INSTANCE, mod, impPrefix);
}
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractUnqualifiedStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.BoundStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
public final class BelongsToStatementSupport
extends AbstractUnqualifiedStatementSupport<BelongsToStatement, BelongsToEffectiveStatement> {
final Mutable<Unqualified, BelongsToStatement, BelongsToEffectiveStatement> belongsToCtx) {
ModelActionBuilder belongsToAction = belongsToCtx.newInferenceAction(ModelProcessingPhase.SOURCE_LINKAGE);
- final var belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx,
- SourceParserNamespaces.MODULE_FOR_BELONGSTO, belongsToCtx.getArgument(),
- ModelProcessingPhase.SOURCE_LINKAGE);
+ final var belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx, ParserNamespaces.MODULE_FOR_BELONGSTO,
+ belongsToCtx.getArgument(), ModelProcessingPhase.SOURCE_LINKAGE);
belongsToAction.apply(new InferenceAction() {
@Override
public void apply(final InferenceContext ctx) {
- belongsToCtx.addToNs(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX,
+ belongsToCtx.addToNs(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX,
findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).getArgument(),
belongsToPrereq.resolve(ctx));
}
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.BoundStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
public final class DeviationStatementSupport
extends AbstractStatementSupport<Absolute, DeviationStatement, DeviationEffectiveStatement> {
@Override
public void onFullDefinitionDeclared(
final Mutable<Absolute, DeviationStatement, DeviationEffectiveStatement> ctx) {
- final QNameModule currentModule = ctx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME,
- ctx.getRoot());
+ final QNameModule currentModule = ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, ctx.getRoot());
final QNameModule targetModule = Iterables.getLast(ctx.getArgument().getNodeIdentifiers()).getModule();
if (currentModule.equals(targetModule)) {
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
public final class FeatureStatementSupport
extends AbstractQNameStatementSupport<FeatureStatement, FeatureEffectiveStatement> {
stmt.addContext(ParserNamespaces.FEATURE, stmt.getArgument(), stmt);
// Do not build effective statement if supported features does not include this feature
- final var supportedFeatures = stmt.getFromNamespace(SourceParserNamespaces.SUPPORTED_FEATURES, Empty.value());
+ final var supportedFeatures = stmt.getFromNamespace(ParserNamespaces.SUPPORTED_FEATURES, Empty.value());
if (supportedFeatures != null && !supportedFeatures.contains(stmt.getArgument())) {
stmt.setUnsupported();
}
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.source.YangVersionLinkageException;
@Beta
"Cannot include a version %s submodule in a version %s module", subVersion, modVersion);
}
- stmt.addToNs(SourceParserNamespaces.INCLUDED_MODULE,
+ stmt.addToNs(ParserNamespaces.INCLUDED_MODULE,
new SourceIdentifier(submoduleName, revision != null ? revision.getArgument() : null),
includedSubModuleContext);
- stmt.addToNs(SourceParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX, stmt.argument(),
+ stmt.addToNs(ParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX, stmt.argument(),
includedSubModuleContext);
}
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveModule;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
final class ModuleEffectiveStatementImpl extends AbstractEffectiveModule<ModuleStatement, ModuleEffectiveStatement>
implements Module, ModuleEffectiveStatement {
namespaceToPrefix = ImmutableMap.copyOf(tmp);
final Map<Unqualified, StmtContext<?, ?, ?>> includedSubmodules =
- stmt.localNamespacePortion(SourceParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
+ stmt.localNamespacePortion(ParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
nameToSubmodule = includedSubmodules == null ? ImmutableMap.of()
: ImmutableMap.copyOf(Maps.transformValues(includedSubmodules,
submodule -> (SubmoduleEffectiveStatement) submodule.buildEffective()));
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
@Beta
public final class ModuleStatementSupport
final XMLNamespace moduleNs = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class), stmt,
"Namespace of the module [%s] is missing", moduleName);
- stmt.addToNs(SourceParserNamespaces.MODULE_NAME_TO_NAMESPACE, moduleName, moduleNs);
+ stmt.addToNs(ParserNamespaces.MODULE_NAME_TO_NAMESPACE, moduleName, moduleNs);
final String modulePrefix = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class), stmt,
"Prefix of the module [%s] is missing", moduleName);
- stmt.addToNs(SourceParserNamespaces.IMP_PREFIX_TO_NAMESPACE, modulePrefix, moduleNs);
+ stmt.addToNs(ParserNamespaces.IMP_PREFIX_TO_NAMESPACE, modulePrefix, moduleNs);
stmt.addContext(ParserNamespaces.PRELINKAGE_MODULE, moduleName, stmt);
final Revision revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()).orElse(null);
final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate).intern();
- stmt.addToNs(SourceParserNamespaces.MODULECTX_TO_QNAME, stmt, qNameModule);
+ stmt.addToNs(ParserNamespaces.MODULECTX_TO_QNAME, stmt, qNameModule);
stmt.setRootIdentifier(new SourceIdentifier(stmt.getArgument(), revisionDate));
}
final SourceIdentifier moduleIdentifier = new SourceIdentifier(moduleName, revisionDate);
stmt.addContext(ParserNamespaces.MODULE, moduleIdentifier, stmt);
- stmt.addContext(SourceParserNamespaces.MODULE_FOR_BELONGSTO, moduleName, stmt);
+ stmt.addContext(ParserNamespaces.MODULE_FOR_BELONGSTO, moduleName, stmt);
stmt.addContext(ParserNamespaces.NAMESPACE_TO_MODULE, qNameModule, stmt);
final String modulePrefix = SourceException.throwIfNull(
"Prefix of the module [%s] is missing", stmt.argument());
stmt.addToNs(QNameModuleNamespace.INSTANCE, Empty.value(), qNameModule);
- stmt.addToNs(SourceParserNamespaces.PREFIX_TO_MODULE, modulePrefix, qNameModule);
- stmt.addToNs(SourceParserNamespaces.MODULE_NAME_TO_QNAME, moduleName, qNameModule);
- stmt.addToNs(SourceParserNamespaces.MODULECTX_TO_QNAME, stmt, qNameModule);
- stmt.addToNs(SourceParserNamespaces.MODULECTX_TO_SOURCE, stmt, moduleIdentifier);
- stmt.addToNs(SourceParserNamespaces.MODULE_NAMESPACE_TO_NAME, qNameModule, moduleName);
- stmt.addToNs(SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, modulePrefix, stmt);
+ stmt.addToNs(ParserNamespaces.PREFIX_TO_MODULE, modulePrefix, qNameModule);
+ stmt.addToNs(ParserNamespaces.MODULE_NAME_TO_QNAME, moduleName, qNameModule);
+ stmt.addToNs(ParserNamespaces.MODULECTX_TO_QNAME, stmt, qNameModule);
+ stmt.addToNs(ParserNamespaces.MODULECTX_TO_SOURCE, stmt, moduleIdentifier);
+ stmt.addToNs(ParserNamespaces.MODULE_NAMESPACE_TO_NAME, qNameModule, moduleName);
+ stmt.addToNs(ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, modulePrefix, stmt);
}
@Override
private static Collection<StmtContext<?, ?, ?>> submoduleContexts(final Current<?, ?> stmt) {
final Map<Unqualified, StmtContext<?, ?, ?>> submodules = stmt.localNamespacePortion(
- SourceParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
+ ParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
return submodules == null ? List.of() : submodules.values();
}
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveModule;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
final class SubmoduleEffectiveStatementImpl
extends AbstractEffectiveModule<SubmoduleStatement, SubmoduleEffectiveStatement>
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements, findSubmodulePrefix(stmt, substatements));
- final QNameModule belongsToModuleQName = stmt.getFromNamespace(SourceParserNamespaces.MODULE_NAME_TO_QNAME,
+ final QNameModule belongsToModuleQName = stmt.getFromNamespace(ParserNamespaces.MODULE_NAME_TO_QNAME,
findBelongsTo(stmt, substatements).argument());
final Builder<String, ModuleEffectiveStatement> prefixToModuleBuilder = ImmutableMap.builder();
* sealing of this statement.
*/
final Map<Unqualified, StmtContext<?, ?, ?>> includedSubmodulesMap = stmt.localNamespacePortion(
- SourceParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
+ ParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
if (includedSubmodulesMap != null) {
final Set<StmtContext<?, SubmoduleStatement, SubmoduleEffectiveStatement>> submoduleContextsInit =
new HashSet<>();
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
@Beta
public final class SubmoduleStatementSupport
"Prefix of belongsTo statement is missing in submodule [%s]", stmt.rawArgument());
final String prefix = prefixSubStmtCtx.rawArgument();
- stmt.addToNs(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME, prefix, belongsToModuleName);
+ stmt.addToNs(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME, prefix, belongsToModuleName);
}
@Override
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundles;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundles.ValidationBundleType;
import org.slf4j.Logger;
private static QNameModule getNewQNameModule(final StmtContext<?, ?, ?> targetCtx,
final StmtContext<?, ?, ?> stmtContext) {
if (targetCtx.getParentContext() == null) {
- return targetCtx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, targetCtx);
+ return targetCtx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, targetCtx);
}
if (targetCtx.publicDefinition() == YangStmtMapping.AUGMENT) {
return StmtContextUtils.getRootModuleQName(targetCtx);
public static final @NonNull NamespaceBehaviour<?, ?> PRELINKAGE_MODULE =
NamespaceBehaviour.global(ParserNamespaces.PRELINKAGE_MODULE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BELONGSTO_PREFIX_TO_MODULECTX =
+ NamespaceBehaviour.sourceLocal(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> BELONGSTO_PREFIX_TO_MODULE_NAME =
+ NamespaceBehaviour.sourceLocal(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAME_TO_QNAME =
+ NamespaceBehaviour.sourceLocal(ParserNamespaces.MODULE_NAME_TO_QNAME);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> IMPORTED_MODULE =
+ NamespaceBehaviour.sourceLocal(ParserNamespaces.IMPORTED_MODULE);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> INCLUDED_MODULE =
+ NamespaceBehaviour.sourceLocal(ParserNamespaces.INCLUDED_MODULE);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULECTX_TO_QNAME =
+ NamespaceBehaviour.global(ParserNamespaces.MODULECTX_TO_QNAME);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> INCLUDED_SUBMODULE_NAME_TO_MODULECTX =
+ NamespaceBehaviour.sourceLocal(ParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> IMP_PREFIX_TO_NAMESPACE =
+ NamespaceBehaviour.rootStatementLocal(ParserNamespaces.IMP_PREFIX_TO_NAMESPACE);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> IMPORT_PREFIX_TO_MODULECTX =
+ NamespaceBehaviour.rootStatementLocal(ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_FOR_BELONGSTO =
+ NamespaceBehaviour.global(ParserNamespaces.MODULE_FOR_BELONGSTO);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> SUPPORTED_FEATURES =
+ NamespaceBehaviour.global(ParserNamespaces.SUPPORTED_FEATURES);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> PREFIX_TO_MODULE =
+ NamespaceBehaviour.global(ParserNamespaces.PREFIX_TO_MODULE);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULES_DEVIATED_BY =
+ NamespaceBehaviour.global(ParserNamespaces.MODULES_DEVIATED_BY);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAMESPACE_TO_NAME =
+ NamespaceBehaviour.global(ParserNamespaces.MODULE_NAMESPACE_TO_NAME);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAME_TO_NAMESPACE =
+ NamespaceBehaviour.global(ParserNamespaces.MODULE_NAME_TO_NAMESPACE);
+
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULECTX_TO_SOURCE =
+ NamespaceBehaviour.global(ParserNamespaces.MODULECTX_TO_SOURCE);
+
private NamespaceBehaviours() {
// Hidden on purpose
}
*/
package org.opendaylight.yangtools.yang.parser.spi;
+import com.google.common.collect.SetMultimap;
+import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
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.FeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.PrefixResolver;
/**
* Baseline {@link ParserNamespace}s mostly derived from YANG specification.
StmtContext<Unqualified, ModuleStatement, ModuleEffectiveStatement>> PRELINKAGE_MODULE =
new ParserNamespace<>("prelinkage-module");
+ /**
+ * Source-specific mapping of belongsTo prefixes to module identifiers. This mapping allows source-specific context
+ * to correctly populate prefixes map for actual parsing phase and eventually, resolve QName for any valid declared
+ * statement.
+ */
+ public static final @NonNull ParserNamespace<String, StmtContext<?, ?, ?>> BELONGSTO_PREFIX_TO_MODULECTX =
+ new ParserNamespace<>("belongsto-prefix-to-module");
+
+ /**
+ * Source-specific mapping of prefixes to namespaces.
+ */
+ // FIXME: bad javadoc
+ public static final @NonNull ParserNamespace<String, Unqualified> BELONGSTO_PREFIX_TO_MODULE_NAME =
+ new ParserNamespace<>("belongsto-prefix-to-name");
+
+ /**
+ * Namespace similar to {@link ParserNamespaces#MODULE} for storing modules into Yang model storage but keyed by
+ * plain name.
+ */
+ // FIXME: Better name?
+ public static final @NonNull ParserNamespace<Unqualified,
+ StmtContext<Unqualified, ModuleStatement, ModuleEffectiveStatement>> MODULE_FOR_BELONGSTO =
+ new ParserNamespace<>("module-belongsto");
+
+ /**
+ * Pre-linkage source-specific mapping of prefixes to module namespaces.
+ */
+ // FIXME: a better name?
+ public static final @NonNull ParserNamespace<String, XMLNamespace> IMP_PREFIX_TO_NAMESPACE =
+ new ParserNamespace<>("prefix-to-xmlnamespace");
+
+ /**
+ * Source-specific mapping of prefix strings to module context.
+ */
+ // FIXME: the context should expose ModuleStatement
+ public static final @NonNull ParserNamespace<String, StmtContext<?, ?, ?>> IMPORT_PREFIX_TO_MODULECTX =
+ new ParserNamespace<>("import-prefix-to-modulectx");
+
+ // FIXME: document this
+ public static final @NonNull ParserNamespace<SourceIdentifier, StmtContext<?, ?, ?>> IMPORTED_MODULE =
+ new ParserNamespace<>("imported-module");
+
+ // FIXME: document this
+ // FIXME: is this 'included submodule' instead?
+ public static final @NonNull ParserNamespace<SourceIdentifier, StmtContext<?, ?, ?>> INCLUDED_MODULE =
+ new ParserNamespace<>("included-module");
+
+ /**
+ * Source-specific mapping of prefixes to namespaces.
+ */
+ // FIXME: bad javadoc
+ // FIXME: the context should expose SubmoduleStatement
+ public static final @NonNull ParserNamespace<Unqualified, StmtContext<?, ?, ?>> INCLUDED_SUBMODULE_NAME_TO_MODULECTX
+ = new ParserNamespace<>("included-submodule-to-modulectx");
+
+ /**
+ * Source-specific mapping of prefixes to namespaces.
+ */
+ // FIXME: bad javadoc
+ public static final @NonNull ParserNamespace<Unqualified, QNameModule> MODULE_NAME_TO_QNAME =
+ new ParserNamespace<>("module-name-to-qnamemodule");
+
+ /**
+ * Global mapping of modules to QNameModules.
+ */
+ public static final @NonNull ParserNamespace<StmtContext<?, ?, ?>, QNameModule> MODULECTX_TO_QNAME =
+ new ParserNamespace<>("modulectx-to-qnamemodule");
+
+ public static final @NonNull ParserNamespace<Empty, Set<QName>> SUPPORTED_FEATURES =
+ new ParserNamespace<>("supportedFeatures");
+
+ /**
+ * Source-specific mapping of prefixes to namespaces. This namespace is populated by all statements which have
+ * impact on the XML namespace, for example {@code import}, {@code belongs-to} and really anywhere a {@code prefix}
+ * statement is present.
+ *
+ * @see PrefixResolver
+ */
+ public static final @NonNull ParserNamespace<String, QNameModule> PREFIX_TO_MODULE =
+ new ParserNamespace<>("prefix-to-qnamemodule");
+
+ /**
+ * Namespace used for storing information about modules that support deviation resolution.
+ * Map key (QNameModule) denotes a module which can be deviated by the modules specified in the Map value.
+ */
+ public static final @NonNull ParserNamespace<Empty, SetMultimap<QNameModule, QNameModule>> MODULES_DEVIATED_BY =
+ new ParserNamespace<>("moduleDeviations");
+
+ /**
+ * Source-specific mapping of prefixes to namespaces.
+ */
+ // FIXME: bad javadoc
+ public static final @NonNull ParserNamespace<QNameModule, Unqualified> MODULE_NAMESPACE_TO_NAME =
+ new ParserNamespace<>("qnamemodule-to-name");
+
+ /**
+ * Pre-linkage global mapping of module names to namespaces.
+ */
+ public static final @NonNull ParserNamespace<Unqualified, XMLNamespace> MODULE_NAME_TO_NAMESPACE =
+ new ParserNamespace<>("module-name-to-xmlnamespace");
+
+ /**
+ * Global mapping of modules to source identifier.
+ */
+ public static final @NonNull ParserNamespace<StmtContext<?, ?, ?>, SourceIdentifier> MODULECTX_TO_SOURCE =
+ new ParserNamespace<>("modulectx-to-source");
+
private ParserNamespaces() {
// Hidden on purpose
}
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
+import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
public final class StmtContextUtils {
private StmtContextUtils() {
if (ctx.producesDeclared(ModuleStatement.class)) {
return lookupModuleQName(ctx, ctx);
} else if (ctx.producesDeclared(SubmoduleStatement.class)) {
- final var belongsTo = ctx.getAllFromNamespace(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX);
+ final var belongsTo = ctx.getAllFromNamespace(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX);
if (belongsTo == null || belongsTo.isEmpty()) {
throw new IllegalArgumentException(ctx + " does not have belongs-to linkage resolved");
}
private static @NonNull QNameModule lookupModuleQName(final NamespaceStmtCtx storage,
final StmtContext<?, ?, ?> module) {
- final var ret = storage.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, module);
+ final var ret = storage.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, module);
if (ret == null) {
throw new IllegalArgumentException("Failed to look up QNameModule for " + module + " in " + storage);
}
public static QNameModule getModuleQNameByPrefix(final StmtContext<?, ?, ?> ctx, final String prefix) {
final StmtContext<?, ?, ?> root = ctx.getRoot();
final StmtContext<?, ?, ?> importedModule = root.getFromNamespace(
- SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, prefix);
- final QNameModule qnameModule = ctx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, importedModule);
+ ParserNamespaces.IMPORT_PREFIX_TO_MODULECTX, prefix);
+ final QNameModule qnameModule = ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, importedModule);
if (qnameModule != null) {
return qnameModule;
}
if (root.producesDeclared(SubmoduleStatement.class)) {
- return ctx.getFromNamespace(SourceParserNamespaces.MODULE_NAME_TO_QNAME,
- root.getFromNamespace(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME, prefix));
+ return ctx.getFromNamespace(ParserNamespaces.MODULE_NAME_TO_QNAME,
+ root.getFromNamespace(ParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME, prefix));
}
return null;
import java.util.Map.Entry;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceParserNamespaces;
public final class SubstatementValidator {
private final ImmutableMap<StatementDefinition, Cardinality> cardinalityMap;
final StmtContext<?, ?, ?> root = ctx.getRoot();
throw new InvalidSubstatementException(ctx, "%s is not valid for %s. Error in module %s (%s)", key,
currentStatement, root.rawArgument(),
- ctx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, root));
+ ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, root));
}
continue;
throw new InvalidSubstatementException(ctx,
"Minimal count of %s for %s is %s, detected %s. Error in module %s (%s)", key, currentStatement,
cardinality.getMin(), value, root.rawArgument(),
- ctx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, root));
+ ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, root));
}
// Encountered a mandatory statement, hence we are not missing it
throw new InvalidSubstatementException(ctx,
"Maximal count of %s for %s is %s, detected %s. Error in module %s (%s)", key, currentStatement,
cardinality.getMax(), value, root.rawArgument(),
- ctx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, root));
+ ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, root));
}
}
throw new MissingSubstatementException(ctx,
"%s is missing %s. Minimal count is %s. Error in module %s (%s)", currentStatement, e.getKey(),
e.getValue().getMin(), root.rawArgument(),
- ctx.getFromNamespace(SourceParserNamespaces.MODULECTX_TO_QNAME, root));
+ ctx.getFromNamespace(ParserNamespaces.MODULECTX_TO_QNAME, root));
}
}
+++ /dev/null
-/*
- * Copyright (c) 2022 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.yang.parser.spi.source;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-
-/**
- * {@link NamespaceBehaviour}s corresponding to {@link SourceParserNamespaces}.
- */
-public final class SourceNamespaceBehaviours {
- public static final @NonNull NamespaceBehaviour<?, ?> BELONGSTO_PREFIX_TO_MODULECTX =
- NamespaceBehaviour.sourceLocal(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULECTX);
-
- public static final @NonNull NamespaceBehaviour<?, ?> BELONGSTO_PREFIX_TO_MODULE_NAME =
- NamespaceBehaviour.sourceLocal(SourceParserNamespaces.BELONGSTO_PREFIX_TO_MODULE_NAME);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAME_TO_QNAME =
- NamespaceBehaviour.sourceLocal(SourceParserNamespaces.MODULE_NAME_TO_QNAME);
-
- public static final @NonNull NamespaceBehaviour<?, ?> IMPORTED_MODULE =
- NamespaceBehaviour.sourceLocal(SourceParserNamespaces.IMPORTED_MODULE);
-
- public static final @NonNull NamespaceBehaviour<?, ?> INCLUDED_MODULE =
- NamespaceBehaviour.sourceLocal(SourceParserNamespaces.INCLUDED_MODULE);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULECTX_TO_QNAME =
- NamespaceBehaviour.global(SourceParserNamespaces.MODULECTX_TO_QNAME);
-
- public static final @NonNull NamespaceBehaviour<?, ?> INCLUDED_SUBMODULE_NAME_TO_MODULECTX =
- NamespaceBehaviour.sourceLocal(SourceParserNamespaces.INCLUDED_SUBMODULE_NAME_TO_MODULECTX);
-
- public static final @NonNull NamespaceBehaviour<?, ?> IMP_PREFIX_TO_NAMESPACE =
- NamespaceBehaviour.rootStatementLocal(SourceParserNamespaces.IMP_PREFIX_TO_NAMESPACE);
-
- public static final @NonNull NamespaceBehaviour<?, ?> IMPORT_PREFIX_TO_MODULECTX =
- NamespaceBehaviour.rootStatementLocal(SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULE_FOR_BELONGSTO =
- NamespaceBehaviour.global(SourceParserNamespaces.MODULE_FOR_BELONGSTO);
-
- public static final @NonNull NamespaceBehaviour<?, ?> SUPPORTED_FEATURES =
- NamespaceBehaviour.global(SourceParserNamespaces.SUPPORTED_FEATURES);
-
- public static final @NonNull NamespaceBehaviour<?, ?> PREFIX_TO_MODULE =
- NamespaceBehaviour.global(SourceParserNamespaces.PREFIX_TO_MODULE);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULES_DEVIATED_BY =
- NamespaceBehaviour.global(SourceParserNamespaces.MODULES_DEVIATED_BY);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAMESPACE_TO_NAME =
- NamespaceBehaviour.global(SourceParserNamespaces.MODULE_NAMESPACE_TO_NAME);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAME_TO_NAMESPACE =
- NamespaceBehaviour.global(SourceParserNamespaces.MODULE_NAME_TO_NAMESPACE);
-
- public static final @NonNull NamespaceBehaviour<?, ?> MODULECTX_TO_SOURCE =
- NamespaceBehaviour.global(SourceParserNamespaces.MODULECTX_TO_SOURCE);
-
- private SourceNamespaceBehaviours() {
- // Hidden on purpose
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2022 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.yang.parser.spi.source;
-
-import com.google.common.collect.SetMultimap;
-import java.util.Set;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.Empty;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
-import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-
-/**
- * Namespaces related to YANG/YIN source processing.
- */
-public final class SourceParserNamespaces {
- /**
- * Source-specific mapping of belongsTo prefixes to module identifiers. This mapping allows source-specific context
- * to correctly populate prefixes map for actual parsing phase and eventually, resolve QName for any valid declared
- * statement.
- */
- public static final @NonNull ParserNamespace<String, StmtContext<?, ?, ?>> BELONGSTO_PREFIX_TO_MODULECTX =
- new ParserNamespace<>("belongsto-prefix-to-module");
-
- /**
- * Source-specific mapping of prefixes to namespaces.
- */
- // FIXME: bad javadoc
- public static final @NonNull ParserNamespace<String, Unqualified> BELONGSTO_PREFIX_TO_MODULE_NAME =
- new ParserNamespace<>("belongsto-prefix-to-name");
-
- /**
- * Namespace similar to {@link ParserNamespaces#MODULE} for storing modules into Yang model storage but keyed by
- * plain name.
- */
- // FIXME: Better name?
- public static final @NonNull ParserNamespace<Unqualified,
- StmtContext<Unqualified, ModuleStatement, ModuleEffectiveStatement>> MODULE_FOR_BELONGSTO =
- new ParserNamespace<>("module-belongsto");
-
- /**
- * Pre-linkage source-specific mapping of prefixes to module namespaces.
- */
- // FIXME: a better name?
- public static final @NonNull ParserNamespace<String, XMLNamespace> IMP_PREFIX_TO_NAMESPACE =
- new ParserNamespace<>("prefix-to-xmlnamespace");
-
- /**
- * Source-specific mapping of prefix strings to module context.
- */
- public static final @NonNull ParserNamespace<String, StmtContext<?, ?, ?>> IMPORT_PREFIX_TO_MODULECTX =
- new ParserNamespace<>("import-prefix-to-modulectx");
-
- // FIXME: document this
- public static final @NonNull ParserNamespace<SourceIdentifier, StmtContext<?, ?, ?>> IMPORTED_MODULE =
- new ParserNamespace<>("imported-module");
-
- // FIXME: document this
- // FIXME: is this 'included submodule' instead?
- public static final @NonNull ParserNamespace<SourceIdentifier, StmtContext<?, ?, ?>> INCLUDED_MODULE =
- new ParserNamespace<>("included-module");
-
- /**
- * Source-specific mapping of prefixes to namespaces.
- */
- // FIXME: bad javadoc
- public static final @NonNull ParserNamespace<Unqualified, StmtContext<?, ?, ?>> INCLUDED_SUBMODULE_NAME_TO_MODULECTX
- = new ParserNamespace<>("included-submodule-to-modulectx");
-
- /**
- * Source-specific mapping of prefixes to namespaces.
- */
- // FIXME: bad javadoc
- public static final @NonNull ParserNamespace<Unqualified, QNameModule> MODULE_NAME_TO_QNAME =
- new ParserNamespace<>("module-name-to-qnamemodule");
-
- /**
- * Global mapping of modules to QNameModules.
- */
- public static final @NonNull ParserNamespace<StmtContext<?, ?, ?>, QNameModule> MODULECTX_TO_QNAME =
- new ParserNamespace<>("modulectx-to-qnamemodule");
-
- public static final @NonNull ParserNamespace<Empty, Set<QName>> SUPPORTED_FEATURES =
- new ParserNamespace<>("supportedFeatures");
-
- /**
- * Source-specific mapping of prefixes to namespaces. This namespace is populated by all statements which have
- * impact on the XML namespace, for example {@code import}, {@code belongs-to} and really anywhere a {@code prefix}
- * statement is present.
- *
- * @see PrefixResolver
- */
- public static final @NonNull ParserNamespace<String, QNameModule> PREFIX_TO_MODULE =
- new ParserNamespace<>("prefix-to-qnamemodule");
-
- /**
- * Namespace used for storing information about modules that support deviation resolution.
- * Map key (QNameModule) denotes a module which can be deviated by the modules specified in the Map value.
- */
- public static final @NonNull ParserNamespace<Empty, SetMultimap<QNameModule, QNameModule>> MODULES_DEVIATED_BY =
- new ParserNamespace<>("moduleDeviations");
-
- /**
- * Source-specific mapping of prefixes to namespaces.
- */
- // FIXME: bad javadoc
- public static final @NonNull ParserNamespace<QNameModule, Unqualified> MODULE_NAMESPACE_TO_NAME =
- new ParserNamespace<>("qnamemodule-to-name");
-
- /**
- * Pre-linkage global mapping of module names to namespaces.
- */
- public static final @NonNull ParserNamespace<Unqualified, XMLNamespace> MODULE_NAME_TO_NAMESPACE =
- new ParserNamespace<>("module-name-to-xmlnamespace");
-
- /**
- * Global mapping of modules to source identifier.
- */
- public static final @NonNull ParserNamespace<StmtContext<?, ?, ?>, SourceIdentifier> MODULECTX_TO_SOURCE =
- new ParserNamespace<>("modulectx-to-source");
-
- private SourceParserNamespaces() {
- // Hidden on purpose
- }
-}
Code Review / yangtools.git / commitdiff