return (Map<K, V>) local.get(type);
}
- final <K, V, T extends K, U extends V> void addToNamespace(final ParserNamespace<K, V> type, final T key,
- final U value) {
+ final <K, V> void addToNamespace(final ParserNamespace<K, V> type, final K key, final V value) {
accessNamespace(type).valueTo(this, key, value);
}
@Override
@Deprecated
- public <K, V, T extends K, U extends V> void addToNs(final ParserNamespace<K, V> type, final T key, final U value) {
+ public <K, V> void addToNs(final ParserNamespace<K, V> type, final K key, final V value) {
throw new UnsupportedOperationException();
}
throw new UnsupportedOperationException();
}
- @Override
- @Deprecated
- public <K, KT extends K, C extends StmtContext<?, ?, ?>> void addContext(
- final ParserNamespace<K, ? super C> namespace, final KT key, final C stmt) {
- throw new UnsupportedOperationException();
- }
-
@Override
@Deprecated
public void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
}
@Override
- public final <K, V, T extends K, U extends V> void addToNs(final ParserNamespace<K, V> type, final T key,
- final U value) {
+ public final <K, V> void addToNs(final ParserNamespace<K, V> type, final K key, final V value) {
addToNamespace(type, key, value);
}
}
}
- @Override
- public final <K, KT extends K, C extends StmtContext<?, ?, ?>> void addContext(
- final ParserNamespace<K, ? super C> namespace, final KT key, final C stmt) {
- accessNamespace(namespace).valueTo(this, key, stmt);
- }
-
@Override
public final Optional<Mutable<A, D, E>> copyAsChildOf(final Mutable<?, ?, ?> parent, final CopyType type,
final QNameModule targetModule) {
final Mutable<QName, ExtensionStatement, ExtensionEffectiveStatement> stmt) {
super.onStatementDefinitionDeclared(stmt);
- stmt.addContext(ParserNamespaces.EXTENSION, stmt.getArgument(), stmt);
+ stmt.addToNs(ParserNamespaces.EXTENSION, stmt.getArgument(), stmt);
final StmtContext<QName, ?, ?> argument = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
ArgumentStatement.class);
@Override
public void onFullDefinitionDeclared(final Mutable<QName, FeatureStatement, FeatureEffectiveStatement> stmt) {
super.onFullDefinitionDeclared(stmt);
- stmt.addContext(ParserNamespaces.FEATURE, stmt.getArgument(), stmt);
+ stmt.addToNs(ParserNamespaces.FEATURE, stmt.getArgument(), stmt);
// Do not build effective statement if supported features does not include this feature
final var supportedFeatures = stmt.namespaceItem(ParserNamespaces.SUPPORTED_FEATURES, Empty.value());
// Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling
// declarations and parent declarations which have already been declared.
checkConflict(parent, stmt);
- parent.addContext(ParserNamespaces.GROUPING, stmt.getArgument(), stmt);
+ parent.addToNs(ParserNamespaces.GROUPING, stmt.getArgument(), stmt);
final StmtContext<?, ?, ?> grandParent = parent.getParentContext();
if (grandParent != null) {
// Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling
// declarations and parent declarations which have already been declared.
checkConflict(parent, stmt);
- parent.addContext(ParserNamespaces.TYPE, stmt.getArgument(), stmt);
+ parent.addToNs(ParserNamespaces.TYPE, stmt.getArgument(), stmt);
final StmtContext<?, ?, ?> grandParent = parent.getParentContext();
if (grandParent != null) {
"Prefix of the module [%s] is missing", moduleName);
stmt.addToNs(ParserNamespaces.IMP_PREFIX_TO_NAMESPACE, modulePrefix, moduleNs);
- stmt.addContext(ParserNamespaces.PRELINKAGE_MODULE, moduleName, stmt);
+ stmt.addToNs(ParserNamespaces.PRELINKAGE_MODULE, moduleName, stmt);
final Revision revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()).orElse(null);
final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate).intern();
final Unqualified moduleName = stmt.getArgument();
final SourceIdentifier moduleIdentifier = new SourceIdentifier(moduleName, revisionDate);
- stmt.addContext(ParserNamespaces.MODULE, moduleIdentifier, stmt);
- stmt.addContext(ParserNamespaces.MODULE_FOR_BELONGSTO, moduleName, stmt);
- stmt.addContext(ParserNamespaces.NAMESPACE_TO_MODULE, qNameModule, stmt);
+ stmt.addToNs(ParserNamespaces.MODULE, moduleIdentifier, stmt);
+ stmt.addToNs(ParserNamespaces.MODULE_FOR_BELONGSTO, moduleName, stmt);
+ stmt.addToNs(ParserNamespaces.NAMESPACE_TO_MODULE, qNameModule, stmt);
final String modulePrefix = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class), stmt,
possibleDuplicateSubmodule.sourceReference());
}
- stmt.addContext(ParserNamespaces.SUBMODULE, submoduleIdentifier, stmt);
+ stmt.addToNs(ParserNamespaces.SUBMODULE, submoduleIdentifier, stmt);
final Unqualified belongsToModuleName = firstAttributeOf(stmt.declaredSubstatements(),
BelongsToStatement.class);
/**
* Associate a value with a key within a namespace.
*
+ * @param <K> key type
+ * @param <V> value type
* @param type Namespace type
* @param key Key
* @param value value
- * @param <K> namespace key type
- * @param <V> namespace value type
- * @param <T> key type
- * @param <U> value type
* @throws NamespaceNotAvailableException when the namespace is not available.
*/
- <K, V, T extends K, U extends V> void addToNs(@NonNull ParserNamespace<K, V> type, T key, U value);
+ <K, V> void addToNs(@NonNull ParserNamespace<K, V> type, K key, V value);
@Override
RootStmtContext.Mutable<?, ?, ?> getRoot();
*/
@NonNull ModelActionBuilder newInferenceAction(@NonNull ModelProcessingPhase phase);
- /**
- * Adds s statement to namespace map with a key.
- *
- * @param namespace
- * {@link ParserNamespace} child that determines namespace to be added to
- * @param key
- * of type according to namespace class specification
- * @param stmt
- * to be added to namespace map
- */
- <K, KT extends K, C extends StmtContext<?, ?, ?>> void addContext(
- @NonNull ParserNamespace<K, ? super C> namespace, KT key, C stmt);
-
/**
* Set version of root statement context.
*