// with 'identifier', hence we cannot safely form a QName.
public final class YangDataArgumentNamespace {
public static final @NonNull ParserNamespace<Empty, QName> INSTANCE = new ParserNamespace<>("yangDataArgument");
- public static final @NonNull NamespaceBehaviour<?, ? ,?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<? ,?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private YangDataArgumentNamespace() {
// Hidden on purpose
private final Table<YangVersion, QName, StatementDefinitionContext<?, ?, ?>> definitions = HashBasedTable.create();
private final Map<QName, StatementDefinitionContext<?, ?, ?>> modelDefinedStmtDefs = new HashMap<>();
- private final Map<ParserNamespace<?, ?>, NamespaceBehaviourWithListeners<?, ?, ?>> supportedNamespaces =
+ private final Map<ParserNamespace<?, ?>, NamespaceBehaviourWithListeners<?, ?>> supportedNamespaces =
new HashMap<>();
private final List<MutableStatement> mutableStatementsToSeal = new ArrayList<>();
private final ImmutableMap<ModelProcessingPhase, StatementSupportBundle> supports;
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> getNamespaceBehaviour(
- final N type) {
- NamespaceBehaviourWithListeners<?, ?, ?> potential = supportedNamespaces.get(type);
+ public <K, V> NamespaceBehaviourWithListeners<K, V> getNamespaceBehaviour(final ParserNamespace<K, V> type) {
+ NamespaceBehaviourWithListeners<?, ?> potential = supportedNamespaces.get(type);
if (potential == null) {
final var potentialRaw = verifyNotNull(supports.get(currentPhase)).getNamespaceBehaviour(type);
if (potentialRaw != null) {
* Safe cast, previous checkState checks equivalence of key from which
* type argument are derived
*/
- return (NamespaceBehaviourWithListeners<K, V, N>) potential;
+ return (NamespaceBehaviourWithListeners<K, V>) potential;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
- private <K, V, N extends ParserNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> createNamespaceContext(
- final NamespaceBehaviour<K, V, N> potentialRaw) {
+ private <K, V> NamespaceBehaviourWithListeners<K, V> createNamespaceContext(
+ final NamespaceBehaviour<K, V> potentialRaw) {
if (potentialRaw instanceof DerivedNamespaceBehaviour derived) {
final VirtualNamespaceContext derivedContext = new VirtualNamespaceContext(derived);
getNamespaceBehaviour(derived.getDerivedFrom()).addDerivedNamespace(derivedContext);
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> Map<K, V> namespace(final @NonNull N nsType) {
+ public <K, V> Map<K, V> namespace(final ParserNamespace<K, V> nsType) {
return delegate.namespace(nsType);
}
@Override
- public <K, V, T extends K, N extends ParserNamespace<K, V>> V namespaceItem(final @NonNull N nsType, final T key) {
+ public <K, V, T extends K> V namespaceItem(final ParserNamespace<K, V> nsType, final T key) {
return delegate.namespaceItem(nsType, key);
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> Map<K, V> localNamespacePortion(final @NonNull N nsType) {
+ public <K, V> Map<K, V> localNamespacePortion(final ParserNamespace<K, V> nsType) {
return delegate.localNamespacePortion(nsType);
}
action = null;
}
- private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> @NonNull AbstractPrerequisite<C>
- requiresCtxImpl(final StmtContext<?, ?, ?> context, final N namespace, final K key,
- final ModelProcessingPhase phase) {
+ private <K, C extends StmtContext<?, ?, ?>> @NonNull AbstractPrerequisite<C> requiresCtxImpl(
+ final StmtContext<?, ?, ?> context, final StatementNamespace<K, ?, ?> namespace, final K key,
+ final ModelProcessingPhase phase) {
checkNotRegistered();
AddedToNamespace<C> addedToNs = new AddedToNamespace<>(phase);
return addedToNs;
}
- private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> @NonNull AbstractPrerequisite<C>
- requiresCtxImpl(final StmtContext<?, ?, ?> context, final N namespace,
- final NamespaceKeyCriterion<K> criterion, final ModelProcessingPhase phase) {
+ private <K, C extends StmtContext<?, ?, ?>> @NonNull AbstractPrerequisite<C> requiresCtxImpl(
+ final StmtContext<?, ?, ?> context, final StatementNamespace<K, ?, ?> namespace,
+ final NamespaceKeyCriterion<K> criterion, final ModelProcessingPhase phase) {
checkNotRegistered();
AddedToNamespace<C> addedToNs = new AddedToNamespace<>(phase);
@Override
public <A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
AbstractPrerequisite<StmtContext<A, D, E>> requiresCtx(final StmtContext<A, D, E> context,
- final ModelProcessingPhase phase) {
+ final ModelProcessingPhase phase) {
return requiresCtxImpl(context, phase);
}
@Override
- public <K, N extends StatementNamespace<K, ?, ?>> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
- final StmtContext<?, ?, ?> context, final N namespace, final K key, final ModelProcessingPhase phase) {
+ public <K> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(final StmtContext<?, ?, ?> context,
+ final StatementNamespace<K, ?, ?> namespace, final K key, final ModelProcessingPhase phase) {
return requiresCtxImpl(context, namespace, key, phase);
}
@Override
- public <K, N extends StatementNamespace<K, ?, ?>> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
- final StmtContext<?, ?, ?> context, final N namespace, final NamespaceKeyCriterion<K> criterion,
+ public <K> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(final StmtContext<?, ?, ?> context,
+ final StatementNamespace<K, ?, ?> namespace, final NamespaceKeyCriterion<K> criterion,
final ModelProcessingPhase phase) {
return requiresCtxImpl(context, namespace, criterion, phase);
}
@Override
- public <K, E extends EffectiveStatement<?, ?>, N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>>
- Prerequisite<StmtContext<?, ?, E>> requiresCtxPath(final StmtContext<?, ?, ?> context,
- final N namespace, final Iterable<K> keys, final ModelProcessingPhase phase) {
+ public <K, E extends EffectiveStatement<?, ?>> Prerequisite<StmtContext<?, ?, E>> requiresCtxPath(
+ final StmtContext<?, ?, ?> context, final ParserNamespace<K, ? extends StmtContext<?, ?, ?>> namespace,
+ final Iterable<K> keys, final ModelProcessingPhase phase) {
checkNotRegistered();
- final var ret = new PhaseRequirementInNamespacePath<StmtContext<?, ?, E>, K, N>(EFFECTIVE_MODEL, keys);
+ final var ret = new PhaseRequirementInNamespacePath<StmtContext<?, ?, E>, K>(EFFECTIVE_MODEL, keys);
addReq(ret);
addBootstrap(() -> ret.hookOnto(context, namespace));
return ret;
@Override
@Deprecated
- public <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>> Prerequisite<D>
- requiresDeclared(final StmtContext<?, ?, ?> context, final N namespace, final K key) {
+ public <K, D extends DeclaredStatement<?>> Prerequisite<D> requiresDeclared(final StmtContext<?, ?, ?> context,
+ final StatementNamespace<K, ? extends D, ?> namespace, final K key) {
final AbstractPrerequisite<StmtContext<?, D, ?>> rawContext = requiresCtxImpl(context, namespace, key,
FULL_DECLARATION);
return rawContext.transform(StmtContext::declared);
@Override
@Deprecated
- public <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
- AbstractPrerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(final StmtContext<?, ?, ?> context,
- final N namespace, final K key) {
+ public <K, D extends DeclaredStatement<?>> AbstractPrerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(
+ final StmtContext<?, ?, ?> context, final StatementNamespace<K, ? extends D, ?> namespace, final K key) {
return requiresCtxImpl(context, namespace, key, FULL_DECLARATION);
}
@Override
@Deprecated
- public <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>> Prerequisite<E>
- requiresEffective(final StmtContext<?, ?, ?> context, final N namespace, final K key) {
+ public <K, E extends EffectiveStatement<?, ?>> Prerequisite<E> requiresEffective(final StmtContext<?, ?, ?> context,
+ final StatementNamespace<K, ?, ? extends E> namespace, final K key) {
final AbstractPrerequisite<StmtContext<?, ?, E>> rawContext = requiresCtxImpl(context, namespace, key,
EFFECTIVE_MODEL);
return rawContext.transform(StmtContext::buildEffective);
@Override
@Deprecated
- public <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
- AbstractPrerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(final StmtContext<?, ?, ?> context,
- final N namespace, final K key) {
+ public <K, E extends EffectiveStatement<?, ?>> AbstractPrerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(
+ final StmtContext<?, ?, ?> context, final StatementNamespace<K, ?, ? extends E> namespace, final K key) {
return requiresCtxImpl(contextImpl(context), namespace, key, EFFECTIVE_MODEL);
}
@Override
@Deprecated
- public <N extends ParserNamespace<?, ?>> Prerequisite<Mutable<?, ?, ?>> mutatesNs(final Mutable<?, ?, ?> context,
- final N namespace) {
- return addMutation(new NamespaceMutation<>(contextImpl(context), namespace));
+ public Prerequisite<Mutable<?, ?, ?>> mutatesNs(final Mutable<?, ?, ?> context,
+ final ParserNamespace<?, ?> namespace) {
+ return addMutation(new NamespaceMutation(contextImpl(context), namespace));
}
@Override
- public <K, E extends EffectiveStatement<?, ?>, N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>>
- AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(final StmtContext<?, ?, ?> context,
- final N namespace, final K key) {
+ public <K, E extends EffectiveStatement<?, ?>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(
+ final StmtContext<?, ?, ?> context, final ParserNamespace<K, ? extends StmtContext<?, ?, ?>> namespace,
+ final K key) {
return mutatesCtxImpl(context, namespace, key, EFFECTIVE_MODEL);
}
@Override
- public <K, E extends EffectiveStatement<?, ?>, N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>>
- AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(final StmtContext<?, ?, ?> context,
- final N namespace, final Iterable<K> keys) {
+ public <K, E extends EffectiveStatement<?, ?>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(
+ final StmtContext<?, ?, ?> context, final ParserNamespace<K, ? extends StmtContext<?, ?, ?>> namespace,
+ final Iterable<K> keys) {
checkNotRegistered();
- final var ret = new PhaseModificationInNamespacePath<Mutable<?, ?, E>, K, N>(EFFECTIVE_MODEL, keys);
+ final var ret = new PhaseModificationInNamespacePath<Mutable<?, ?, E>, K>(EFFECTIVE_MODEL, keys);
addReq(ret);
addMutation(ret);
addBootstrap(() -> ret.hookOnto(context, namespace));
}
}
- private abstract class AbstractPathPrerequisite<C extends StmtContext<?, ?, ?>, K,
- N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPrerequisite<C>
+ private abstract class AbstractPathPrerequisite<C extends StmtContext<?, ?, ?>, K> extends AbstractPrerequisite<C>
implements OnNamespaceItemAdded {
private final ModelProcessingPhase modPhase;
private final Iterable<K> keys;
}
}
- private final class NamespaceMutation<N extends ParserNamespace<?, ?>>
- extends AbstractPrerequisite<Mutable<?, ?, ?>> {
- NamespaceMutation(final StatementContextBase<?, ?, ?> ctx, final N namespace) {
+ private final class NamespaceMutation extends AbstractPrerequisite<Mutable<?, ?, ?>> {
+ NamespaceMutation(final StatementContextBase<?, ?, ?> ctx, final ParserNamespace<?, ?> namespace) {
resolvePrereq(ctx);
}
}
}
}
- private final class PhaseRequirementInNamespacePath<C extends StmtContext<?, ?, ?>, K,
- N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPathPrerequisite<C, K, N> {
+ private final class PhaseRequirementInNamespacePath<C extends StmtContext<?, ?, ?>, K>
+ extends AbstractPathPrerequisite<C, K> {
PhaseRequirementInNamespacePath(final ModelProcessingPhase phase, final Iterable<K> keys) {
super(phase, keys);
}
* target. The mechanics is driven as a sequence of prerequisites along a path: first we hook onto namespace to
* give us the first step. When it does, we hook onto the first item to provide us the second step and so on.
*/
- private final class PhaseModificationInNamespacePath<C extends Mutable<?, ?, ?>, K,
- N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPathPrerequisite<C, K, N>
- implements ContextMutation {
+ private final class PhaseModificationInNamespacePath<C extends Mutable<?, ?, ?>, K>
+ extends AbstractPathPrerequisite<C, K> implements ContextMutation {
PhaseModificationInNamespacePath(final ModelProcessingPhase phase, final Iterable<K> keys) {
super(phase, keys);
}
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
-
-abstract class NamespaceBehaviourWithListeners<K, V, N extends ParserNamespace<K, V>>
- extends NamespaceBehaviour<K, V, N> {
+abstract class NamespaceBehaviourWithListeners<K, V> extends NamespaceBehaviour<K, V> {
abstract static class ValueAddedListener<K> {
private final NamespaceStorageNode ctxNode;
return key;
}
- final <V> boolean isRequestedValue(final NamespaceBehaviour<K, ? , ?> behavior,
- final NamespaceStorageNode storage, final V value) {
+ final <V> boolean isRequestedValue(final NamespaceBehaviour<K, ?> behavior, final NamespaceStorageNode storage,
+ final V value) {
return value == behavior.getFrom(getCtxNode(), key);
}
abstract boolean onValueAdded(@NonNull K key, @NonNull V value);
}
- protected final NamespaceBehaviour<K, V, N> delegate;
+ protected final NamespaceBehaviour<K, V> delegate;
- private List<VirtualNamespaceContext<?, V, ?, K>> derivedNamespaces;
+ private List<VirtualNamespaceContext<?, V, K>> derivedNamespaces;
- protected NamespaceBehaviourWithListeners(final NamespaceBehaviour<K, V, N> delegate) {
+ protected NamespaceBehaviourWithListeners(final NamespaceBehaviour<K, V> delegate) {
super(delegate.getIdentifier());
this.delegate = delegate;
}
protected void notifyDerivedNamespaces(final NamespaceStorageNode storage, final K key, final V value) {
if (derivedNamespaces != null) {
- for (VirtualNamespaceContext<?, V, ?, K> derived : derivedNamespaces) {
+ for (VirtualNamespaceContext<?, V, K> derived : derivedNamespaces) {
derived.addedToSourceNamespace(storage, key, value);
}
}
}
- final void addDerivedNamespace(final VirtualNamespaceContext<?, V, ?, K> namespace) {
+ final void addDerivedNamespace(final VirtualNamespaceContext<?, V, K> namespace) {
if (derivedNamespaces == null) {
derivedNamespaces = new ArrayList<>();
}
import java.util.Map.Entry;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry;
*
* @throws SourceException instance of SourceException
*/
- protected <K, V, N extends ParserNamespace<K, V>> void onNamespaceElementAdded(final N type, final K key,
- final V value) {
+ protected <K, V> void onNamespaceElementAdded(final ParserNamespace<K, V> type, final K key, final V value) {
// NOOP
}
- public final <K, V, N extends ParserNamespace<K, V>> Optional<Entry<K, V>> getFromNamespace(final N type,
+ public final <K, V> Optional<Entry<K, V>> getFromNamespace(final ParserNamespace<K, V> type,
final NamespaceKeyCriterion<K> criterion) {
return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this, criterion);
}
- public final <K, V, N extends ParserNamespace<K, V>> Map<K, V> getNamespace(final N type) {
+ public final <K, V> Map<K, V> getNamespace(final ParserNamespace<K, V> type) {
return getBehaviourRegistry().getNamespaceBehaviour(type).getAllFrom(this);
}
@SuppressWarnings("unchecked")
- final <K, V, N extends ParserNamespace<K, V>> Map<K, V> getLocalNamespace(final N type) {
+ final <K, V> Map<K, V> getLocalNamespace(final ParserNamespace<K, V> type) {
return (Map<K, V>) accessNamespaces().get(type);
}
getBehaviourRegistry().getNamespaceBehaviour(type).addTo(this, key, value);
}
- final <K, V, T extends K, U extends V, N extends ParserNamespace<K, V>> void addToNamespace(final N type,
- final Map<T, U> map) {
- final NamespaceBehaviour<K, V, N> behavior = getBehaviourRegistry().getNamespaceBehaviour(type);
+ final <K, V, T extends K, U extends V> void addToNamespace(final ParserNamespace<K, V> type, final Map<T, U> map) {
+ final NamespaceBehaviour<K, V> behavior = getBehaviourRegistry().getNamespaceBehaviour(type);
for (final Entry<T, U> validationBundle : map.entrySet()) {
behavior.addTo(this, validationBundle.getKey(), validationBundle.getValue());
}
* @param key Key
* @param value Context value
* @param <K> namespace key type
- * @param <N> namespace type
+ * @param <D> declared statement type
+ * @param <E> effective statement type
* @throws NamespaceNotAvailableException when the namespace is not available.
*/
- @SuppressWarnings({ "unchecked", "rawtypes" })
- public final <K, N extends StatementNamespace<K, ?,?>> void addContextToNamespace(final N type, final K key,
- final StmtContext<?, ?, ?> value) {
+ public final <K, D extends DeclaredStatement<?>, E extends EffectiveStatement<?, D>> void addContextToNamespace(
+ final StatementNamespace<K, D, E> type, final K key, final StmtContext<?, D, E> value) {
getBehaviourRegistry().getNamespaceBehaviour(type).addTo(this, key, value);
}
@SuppressWarnings("unchecked")
@Override
- public <K, V, N extends ParserNamespace<K, V>> V getFromLocalStorage(final N type, final K key) {
+ public <K, V> V getFromLocalStorage(final ParserNamespace<K, V> type, final K key) {
final Map<K, V> localNamespace = (Map<K, V>) accessNamespaces().get(type);
return localNamespace == null ? null : localNamespace.get(key);
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> Map<K, V> getAllFromLocalStorage(final N type) {
+ public <K, V> Map<K, V> getAllFromLocalStorage(final ParserNamespace<K, V> type) {
@SuppressWarnings("unchecked")
final Map<K, V> localNamespace = (Map<K, V>) accessNamespaces().get(type);
return localNamespace;
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V putToLocalStorage(final N type, final K key, final V value) {
+ public <K, V> V putToLocalStorage(final ParserNamespace<K, V> type, final K key, final V value) {
final V ret = ensureLocalNamespace(type).put(key, value);
onNamespaceElementAdded(type, key, value);
return ret;
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V putToLocalStorageIfAbsent(final N type, final K key,
- final V value) {
+ public <K, V> V putToLocalStorageIfAbsent(final ParserNamespace<K, V> type, final K key, final V value) {
final V ret = ensureLocalNamespace(type).putIfAbsent(key, value);
if (ret == null) {
onNamespaceElementAdded(type, key, value);
return verifyNotNull(namespaces, "Attempted to access swept namespaces of %s", this);
}
- private <K, V, N extends ParserNamespace<K, V>> Map<K, V> ensureLocalNamespace(final N type) {
+ private <K, V> Map<K, V> ensureLocalNamespace(final ParserNamespace<K, V> type) {
@SuppressWarnings("unchecked")
Map<K, V> ret = (Map<K,V>) accessNamespaces().get(type);
if (ret == null) {
//
@Override
- public final <K, V, T extends K, N extends ParserNamespace<K, V>> V namespaceItem(final @NonNull N type,
- final T key) {
+ public final <K, V, T extends K> V namespaceItem(final ParserNamespace<K, V> type, final T key) {
return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this, key);
}
@Override
- public final <K, V, N extends ParserNamespace<K, V>> Map<K, V> namespace(final @NonNull N type) {
+ public final <K, V> Map<K, V> namespace(final ParserNamespace<K, V> type) {
return getNamespace(type);
}
@Override
- public final <K, V, N extends ParserNamespace<K, V>> Map<K, V> localNamespacePortion(final @NonNull N type) {
+ public final <K, V> Map<K, V> localNamespacePortion(final ParserNamespace<K, V> type) {
return getLocalNamespace(type);
}
@Override
- protected <K, V, N extends ParserNamespace<K, V>> void onNamespaceElementAdded(final N type, final K key,
- final V value) {
+ protected <K, V> void onNamespaceElementAdded(final ParserNamespace<K, V> type, final K key, final V value) {
// definition().onNamespaceElementAdded(this, type, key, value);
}
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
@Override
@Deprecated
- public <K, V, T extends K, U extends V, N extends ParserNamespace<K, V>> void addToNs(final @NonNull N type,
- final T key, final U value) {
+ public <K, V, T extends K, U extends V> void addToNs(final ParserNamespace<K, V> type, final T key, final U value) {
throw new UnsupportedOperationException();
}
@Override
@Deprecated
- public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final @NonNull N namespace,
- final KT key, final StmtContext<?, ?, ?> stmt) {
+ public <K, KT extends K, Y extends DeclaredStatement<?>, Z extends EffectiveStatement<?, Y>> void addContext(
+ final StatementNamespace<K, Y, Z> namespace, final KT key, final StmtContext<?, Y, Z> stmt) {
throw new UnsupportedOperationException();
}
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V putToLocalStorage(final N type, final K key, final V value) {
+ public <K, V> V putToLocalStorage(final ParserNamespace<K, V> type, final K key, final V value) {
if (SourceParserNamespaces.INCLUDED_MODULE.equals(type)) {
if (includedContexts.isEmpty()) {
includedContexts = new ArrayList<>(1);
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V getFromLocalStorage(final N type, final K key) {
+ public <K, V> V getFromLocalStorage(final ParserNamespace<K, V> type, final K key) {
return getFromLocalStorage(type, key, new HashSet<>());
}
* We need to track already checked RootStatementContexts due to possible
* circular chains of includes between submodules
*/
- private <K, V, N extends ParserNamespace<K, V>> @Nullable V getFromLocalStorage(final N type,
- final K key, final HashSet<RootStatementContext<?, ?, ?>> alreadyChecked) {
+ private <K, V> @Nullable V getFromLocalStorage(final ParserNamespace<K, V> type, final K key,
+ final HashSet<RootStatementContext<?, ?, ?>> alreadyChecked) {
final V potentialLocal = super.getFromLocalStorage(type, key);
if (potentialLocal != null) {
return potentialLocal;
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> Map<K, V> getAllFromLocalStorage(final N type) {
+ public <K, V> Map<K, V> getAllFromLocalStorage(final ParserNamespace<K, V> type) {
return getAllFromLocalStorage(type, new HashSet<>());
}
* We need to track already checked RootStatementContexts due to possible
* circular chains of includes between submodules
*/
- private <K, V, N extends ParserNamespace<K, V>> @Nullable Map<K, V> getAllFromLocalStorage(final N type,
+ private <K, V> @Nullable Map<K, V> getAllFromLocalStorage(final ParserNamespace<K, V> type,
final HashSet<RootStatementContext<?, ?, ?>> alreadyChecked) {
final Map<K, V> potentialLocal = super.getAllFromLocalStorage(type);
if (potentialLocal != null) {
import java.util.Iterator;
import java.util.List;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
-final class SimpleNamespaceContext<K, V, N extends ParserNamespace<K, V>>
- extends NamespaceBehaviourWithListeners<K, V, N> {
+final class SimpleNamespaceContext<K, V> extends NamespaceBehaviourWithListeners<K, V> {
// FIXME: Change this to Multimap, once issue with modules is resolved.
private List<KeyedValueAddedListener<K>> listeners;
private Collection<PredicateValueAddedListener<K, V>> predicateListeners;
- SimpleNamespaceContext(final NamespaceBehaviour<K, V, N> delegate) {
+ SimpleNamespaceContext(final NamespaceBehaviour<K, V> delegate) {
super(delegate);
}
FINISHED
}
- private static final class SupportedStatements extends NamespaceBehaviour<QName, StatementSupport<?, ?, ?>,
- ParserNamespace<QName, StatementSupport<?, ?, ?>>> {
+ private static final class SupportedStatements extends NamespaceBehaviour<QName, StatementSupport<?, ?, ?>> {
private final QNameToStatementDefinitionMap statementDefinitions;
SupportedStatements(final QNameToStatementDefinitionMap statementDefinitions) {
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V putToLocalStorage(final N type, final K key, final V value) {
+ public <K, V> V putToLocalStorage(final ParserNamespace<K, V> type, final K key, final V value) {
// RootStatementContext takes care of IncludedModuleContext and the rest...
final V ret = getRoot().putToLocalStorage(type, key, value);
// FIXME: what about duplicates?
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V putToLocalStorageIfAbsent(final N type, final K key,
- final V value) {
+ public <K, V> V putToLocalStorageIfAbsent(final ParserNamespace<K, V> type, final K key, final V value) {
// RootStatementContext takes care of IncludedModuleContext and the rest...
final V ret = getRoot().putToLocalStorageIfAbsent(type, key, value);
if (ret == null) {
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> V getFromLocalStorage(final N type, final K key) {
+ public <K, V> V getFromLocalStorage(final ParserNamespace<K, V> type, final K key) {
final V potentialLocal = getRoot().getFromLocalStorage(type, key);
if (potentialLocal != null) {
return potentialLocal;
}
@Override
- public <K, V, N extends ParserNamespace<K, V>> Map<K, V> getAllFromLocalStorage(final N type) {
+ public <K, V> Map<K, V> getAllFromLocalStorage(final ParserNamespace<K, V> type) {
final Map<K, V> potentialLocal = getRoot().getAllFromLocalStorage(type);
if (potentialLocal != null) {
return potentialLocal;
@Override
@SuppressWarnings("unchecked")
- public <K, V, N extends ParserNamespace<K, V>> NamespaceBehaviour<K, V, N> getNamespaceBehaviour(final N type) {
+ public <K, V> NamespaceBehaviour<K, V> getNamespaceBehaviour(final ParserNamespace<K, V> type) {
if (StatementSupport.NAMESPACE.equals(type)) {
- return (NamespaceBehaviour<K, V, N>) statementSupports;
+ return (NamespaceBehaviour<K, V>) statementSupports;
}
return globalContext.getNamespaceBehaviour(type);
}
}
@Override
- public final <K, V, T extends K, U extends V, N extends ParserNamespace<K, V>> void addToNs(final @NonNull N type,
- final T key, final U value) {
+ public final <K, V, T extends K, U extends V> void addToNs(final ParserNamespace<K, V> type, final T key,
+ final U value) {
addToNamespace(type, key, value);
}
});
}
- final <K, V, N extends ParserNamespace<K, V>> void onNamespaceItemAddedAction(final N type,
+ final <K, V> void onNamespaceItemAddedAction(final ParserNamespace<K, V> type,
final ModelProcessingPhase phase, final NamespaceKeyCriterion<K> criterion,
final OnNamespaceItemAdded listener) {
final Optional<Entry<K, V>> existing = getFromNamespace(type, criterion);
return;
}
- final NamespaceBehaviourWithListeners<K, V, N> behaviour = getBehaviour(type);
+ final NamespaceBehaviourWithListeners<K, V> behaviour = getBehaviour(type);
behaviour.addListener(new PredicateValueAddedListener<K, V>(this) {
@Override
boolean onValueAdded(final K key, final V value) {
});
}
- final <K, V, N extends ParserNamespace<K, V>> void selectMatch(final N type,
- final NamespaceKeyCriterion<K> criterion, final OnNamespaceItemAdded listener) {
+ final <K, V> void selectMatch(final ParserNamespace<K, V> type, final NamespaceKeyCriterion<K> criterion,
+ final OnNamespaceItemAdded listener) {
final Optional<Entry<K, V>> optMatch = getFromNamespace(type, criterion);
checkState(optMatch.isPresent(), "Failed to find a match for criterion %s in namespace %s node %s", criterion,
type, this);
listener.namespaceItemAdded(StatementContextBase.this, type, match.getKey(), match.getValue());
}
- final <K, V, N extends ParserNamespace<K, V>> void waitForPhase(final Object value, final N type,
+ final <K, V> void waitForPhase(final Object value, final ParserNamespace<K, V> type,
final ModelProcessingPhase phase, final NamespaceKeyCriterion<K> criterion,
final OnNamespaceItemAdded listener) {
((StatementContextBase<?, ? ,?>) value).addPhaseCompletedListener(phase,
});
}
- private <K, V, N extends ParserNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> getBehaviour(
- final N type) {
- final NamespaceBehaviour<K, V, N> behaviour = getBehaviourRegistry().getNamespaceBehaviour(type);
+ private <K, V> NamespaceBehaviourWithListeners<K, V> getBehaviour(final ParserNamespace<K, V> type) {
+ final NamespaceBehaviour<K, V> behaviour = getBehaviourRegistry().getNamespaceBehaviour(type);
checkArgument(behaviour instanceof NamespaceBehaviourWithListeners, "Namespace %s does not support listeners",
type);
- return (NamespaceBehaviourWithListeners<K, V, N>) behaviour;
+ return (NamespaceBehaviourWithListeners<K, V>) behaviour;
}
private static <T> Multimap<ModelProcessingPhase, T> newMultimap() {
}
@Override
- public final <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final @NonNull N namespace,
- final KT key, final StmtContext<?, ?, ?> stmt) {
+ public final <K, KT extends K, Y extends DeclaredStatement<?>, Z extends EffectiveStatement<?, Y>> void addContext(
+ final StatementNamespace<K, Y, Z> namespace, final KT key, final StmtContext<?, Y, Z> stmt) {
addContextToNamespace(namespace, key, stmt);
}
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedNamespaceBehaviour;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
-
-final class VirtualNamespaceContext<K, V, N extends ParserNamespace<K, V>, D>
- extends NamespaceBehaviourWithListeners<K, V, N> {
+final class VirtualNamespaceContext<K, V, D> extends NamespaceBehaviourWithListeners<K, V> {
private final Multimap<D, KeyedValueAddedListener<K>> listeners = HashMultimap.create();
- private final DerivedNamespaceBehaviour<K, V, D, N, ?> derivedDelegate;
+ private final DerivedNamespaceBehaviour<K, V, D, ?> derivedDelegate;
- VirtualNamespaceContext(final DerivedNamespaceBehaviour<K, V, D, N, ?> delegate) {
+ VirtualNamespaceContext(final DerivedNamespaceBehaviour<K, V, D, ?> delegate) {
super(delegate);
this.derivedDelegate = delegate;
}
public final class ModuleQNameToPrefix {
public static final @NonNull ParserNamespace<QNameModule, String> INSTANCE =
new ParserNamespace<>("module-qname-to-prefix");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR =
- NamespaceBehaviour.rootStatementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.rootStatementLocal(INSTANCE);
private ModuleQNameToPrefix() {
// Hidden on purpose
public final class YangNamespaceContextNamespace {
public static final @NonNull ParserNamespace<StmtContext<?, ?, ?>, YangNamespaceContext> INSTANCE =
new ParserNamespace<>("yangNamespaceContext");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.global(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.global(INSTANCE);
private YangNamespaceContextNamespace() {
// Hidden on purpose
}
public @NonNull CustomCrossSourceStatementReactorBuilder addNamespaceSupport(final ModelProcessingPhase phase,
- final NamespaceBehaviour<?, ?, ?> namespaceSupport) {
+ final NamespaceBehaviour<?, ?> namespaceSupport) {
getBuilder(phase).addSupport(namespaceSupport);
return this;
}
}
public @NonNull CustomCrossSourceStatementReactorBuilder addAllNamespaceSupports(final ModelProcessingPhase phase,
- final Collection<NamespaceBehaviour<?, ?, ?>> namespaceSupports) {
+ final Collection<NamespaceBehaviour<?, ?>> namespaceSupports) {
final StatementSupportBundle.Builder stmtBundleBuilder = reactorSupportBundles.get(phase);
- for (final NamespaceBehaviour<?, ?, ?> namespaceSupport : namespaceSupports) {
+ for (final NamespaceBehaviour<?, ?> namespaceSupport : namespaceSupports) {
stmtBundleBuilder.addSupport(namespaceSupport);
}
return this;
public final class AugmentImplicitHandlingNamespace {
public static final @NonNull ParserNamespace<Empty, Mutable<?, ?, ?>> INSTANCE =
new ParserNamespace<>("augment-implicit-handling");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private AugmentImplicitHandlingNamespace() {
// Hidden on purpose
public final class ImportedVersionNamespace {
public static final @NonNull ParserNamespace<Empty, SourceIdentifier> INSTANCE =
new ParserNamespace<>("imported-version");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private ImportedVersionNamespace() {
// Hidden on purpose
public final class ConfigListWarningNamespace {
public static final @NonNull ParserNamespace<StatementSourceReference, Boolean> INSTANCE =
new ParserNamespace<>("configListWarning");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.global(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.global(INSTANCE);
private ConfigListWarningNamespace() {
// Hidden on purpose
// ... require that each schema node identifier resolves against the schema tree
Maps.uniqueIndex(unique.getArgument(),
desc -> action.requiresCtxPath(list,
+ // FIXME: why do we need this cast?
(SchemaTreeNamespace) SchemaTreeNamespace.instance(), desc.getNodeIdentifiers(),
ModelProcessingPhase.EFFECTIVE_MODEL))));
}
@Beta
public final class QNameModuleNamespace {
public static final @NonNull ParserNamespace<Empty, QNameModule> INSTANCE = new ParserNamespace<>("QNameModule");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private QNameModuleNamespace() {
// Hidden on purpose
public final class RefineTargetNamespace {
public static final @NonNull ParserNamespace<Empty, StmtContext<?, ?, ?>> INSTANCE =
new ParserNamespace<>("refineTarget");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private RefineTargetNamespace() {
// Hidden on purpose
@Beta
public final class BaseTypeNamespace {
public static final @NonNull ParserNamespace<Empty, Object> INSTANCE = new ParserNamespace<>("baseType");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private BaseTypeNamespace() {
// Hidden on purpose
public final class SourceGroupingNamespace {
public static final @NonNull ParserNamespace<Empty, StmtContext<?, ?, ?>> INSTANCE =
new ParserNamespace<>("sourceGrouping");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private SourceGroupingNamespace() {
// Hidden on purpose
*/
public final class ThirdPartyNamespace {
public static final @NonNull ParserNamespace<Empty, String> INSTANCE = new ParserNamespace<>("third-party");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
private ThirdPartyNamespace() {
// Hidden on purpose
* {@link NamespaceBehaviour}s corresponding to {@link ParserNamespaces}.
*/
public final class NamespaceBehaviours {
- public static final @NonNull NamespaceBehaviour<?, ?, ?> EXTENSION =
+ public static final @NonNull NamespaceBehaviour<?, ?> EXTENSION =
NamespaceBehaviour.global(ParserNamespaces.EXTENSION);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> FEATURE =
- NamespaceBehaviour.global(ParserNamespaces.FEATURE);
+ public static final @NonNull NamespaceBehaviour<?, ?> FEATURE = NamespaceBehaviour.global(ParserNamespaces.FEATURE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> GROUPING =
+ public static final @NonNull NamespaceBehaviour<?, ?> GROUPING =
NamespaceBehaviour.treeScoped(ParserNamespaces.GROUPING);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> IDENTITY =
+ public static final @NonNull NamespaceBehaviour<?, ?> IDENTITY =
NamespaceBehaviour.global(ParserNamespaces.IDENTITY);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> MODULE =
- NamespaceBehaviour.global(ParserNamespaces.MODULE);
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE = NamespaceBehaviour.global(ParserNamespaces.MODULE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> SUBMODULE =
+ public static final @NonNull NamespaceBehaviour<?, ?> SUBMODULE =
NamespaceBehaviour.global(ParserNamespaces.SUBMODULE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> TYPE =
- NamespaceBehaviour.treeScoped(ParserNamespaces.TYPE);
+ public static final @NonNull NamespaceBehaviour<?, ?> TYPE = NamespaceBehaviour.treeScoped(ParserNamespaces.TYPE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> NAMESPACE_TO_MODULE =
+ public static final @NonNull NamespaceBehaviour<?, ?> NAMESPACE_TO_MODULE =
NamespaceBehaviour.global(ParserNamespaces.NAMESPACE_TO_MODULE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> PRELINKAGE_MODULE =
+ public static final @NonNull NamespaceBehaviour<?, ?> PRELINKAGE_MODULE =
NamespaceBehaviour.global(ParserNamespaces.PRELINKAGE_MODULE);
private NamespaceBehaviours() {
* {@link NamespaceBehaviour} handling {@link SchemaTreeNamespace}.
*/
public final class SchemaTreeNamespaceBehaviour<D extends DeclaredStatement<QName>,
- E extends SchemaTreeEffectiveStatement<D>>
- extends NamespaceBehaviour<QName, StmtContext<?, D, E>, SchemaTreeNamespace<D, E>> {
+ E extends SchemaTreeEffectiveStatement<D>> extends NamespaceBehaviour<QName, StmtContext<?, D, E>> {
public static final @NonNull SchemaTreeNamespaceBehaviour<?, ?> INSTANCE = new SchemaTreeNamespaceBehaviour<>();
private SchemaTreeNamespaceBehaviour() {
*
* @param <K> Key type
* @param <V> Value type
- * @param <N> Namespace type
* @param <L> Original key type
* @param <O> Original namespace type
*/
-public abstract class DerivedNamespaceBehaviour<K, V, L, N extends ParserNamespace<K, V>,
- O extends ParserNamespace<L, ?>> extends NamespaceBehaviour<K, V, N> {
+public abstract class DerivedNamespaceBehaviour<K, V, L, O extends ParserNamespace<L, ?>>
+ extends NamespaceBehaviour<K, V> {
private final @NonNull O derivedFrom;
- protected DerivedNamespaceBehaviour(final N identifier, final O derivedFrom) {
+ protected DerivedNamespaceBehaviour(final ParserNamespace<K, V> identifier, final O derivedFrom) {
super(identifier);
this.derivedFrom = requireNonNull(derivedFrom);
}
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
- @NonNull Prerequisite<D> requiresDeclared(StmtContext<?, ?, ?> context, N namespace, K key);
+ <K, D extends DeclaredStatement<?>> @NonNull Prerequisite<D> requiresDeclared(StmtContext<?, ?, ?> context,
+ StatementNamespace<K, ? extends D, ?> namespace, K key);
/**
* Action requires that the specified context completes specified phase before {@link #apply(InferenceAction)}
<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> @NonNull Prerequisite<StmtContext<A, D, E>>
requiresCtx(StmtContext<A, D, E> context, ModelProcessingPhase phase);
- <K, N extends StatementNamespace<K, ?, ?>> @NonNull Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
- StmtContext<?, ?, ?> context, @NonNull N namespace, K key, ModelProcessingPhase phase);
+ <K> @NonNull Prerequisite<StmtContext<?, ?, ?>> requiresCtx(StmtContext<?, ?, ?> context,
+ @NonNull StatementNamespace<K, ?, ?> namespace, K key, ModelProcessingPhase phase);
- <K, N extends StatementNamespace<K, ?, ?>> @NonNull Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
- StmtContext<?, ?, ?> context, @NonNull N namespace, NamespaceKeyCriterion<K> criterion,
- ModelProcessingPhase phase);
+ <K> @NonNull Prerequisite<StmtContext<?, ?, ?>> requiresCtx(StmtContext<?, ?, ?> context,
+ @NonNull StatementNamespace<K, ?, ?> namespace, NamespaceKeyCriterion<K> criterion, ModelProcessingPhase phase);
- <K, E extends EffectiveStatement<?, ?>, N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>>
- @NonNull Prerequisite<StmtContext<?, ?, E>> requiresCtxPath(StmtContext<?, ?, ?> context, N namespace,
- Iterable<K> keys, ModelProcessingPhase phase);
+ <K, E extends EffectiveStatement<?, ?>> @NonNull Prerequisite<StmtContext<?, ?, E>> requiresCtxPath(
+ StmtContext<?, ?, ?> context, ParserNamespace<K, ? extends StmtContext<?, ?, ?>> namespace, Iterable<K> keys,
+ ModelProcessingPhase phase);
/**
* Action mutates the effective model of specified statement. This is a shorthand for
return mutatesCtx(context, EFFECTIVE_MODEL);
}
- <K, E extends EffectiveStatement<?, ?>, N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>>
- @NonNull Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(StmtContext<?, ?, ?> context, N namespace, K key);
+ <K, E extends EffectiveStatement<?, ?>> @NonNull Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(
+ StmtContext<?, ?, ?> context, ParserNamespace<K, ? extends StmtContext<?, ?, ?>> namespace, K key);
- <K, E extends EffectiveStatement<?, ?>, N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>>
- @NonNull Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(StmtContext<?, ?, ?> context,
- N namespace, Iterable<K> keys);
+ <K, E extends EffectiveStatement<?, ?>> @NonNull Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(
+ StmtContext<?, ?, ?> context, ParserNamespace<K, ? extends StmtContext<?, ?, ?>> namespace, Iterable<K> keys);
/**
* Action mutates the specified statement in the specified phase. Target statement cannot complete specified
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
- @NonNull Prerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(StmtContext<?, ?, ?> context,
- N namespace, K key);
+ <K, D extends DeclaredStatement<?>> @NonNull Prerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(
+ StmtContext<?, ?, ?> context, StatementNamespace<K, ? extends D, ?> namespace, K key);
/**
* Create a requirement on specified statement to become effective.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
- @NonNull Prerequisite<E> requiresEffective(StmtContext<?, ?, ?> context, N namespace, K key);
+ <K, E extends EffectiveStatement<?, ?>> @NonNull Prerequisite<E> requiresEffective(StmtContext<?, ?, ?> context,
+ StatementNamespace<K, ?, ? extends E> namespace, K key);
/**
* Create a requirement on specified statement context to become effective.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
- @NonNull Prerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(StmtContext<?, ?, ?> context, N namespace,
- K key);
+ <K, E extends EffectiveStatement<?, ?>> @NonNull Prerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(
+ StmtContext<?, ?, ?> context, StatementNamespace<K, ?, ? extends E> namespace, K key);
/**
* Mark the fact that this action is mutating a namespace.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- <N extends ParserNamespace<?, ?>> @NonNull Prerequisite<Mutable<?,?,?>> mutatesNs(Mutable<?,?, ?> ctx, N namespace);
+ @NonNull Prerequisite<Mutable<?, ?, ?>> mutatesNs(Mutable<?, ?, ?> ctx, ParserNamespace<?, ?> namespace);
}
*
* @param <K> Key type
* @param <V> Value type
- * @param <N> Namespace Type
*/
-// FIXME: remove the 'N' parameter?
-public abstract class NamespaceBehaviour<K, V, N extends ParserNamespace<K, V>> extends AbstractSimpleIdentifiable<N> {
+public abstract class NamespaceBehaviour<K, V> extends AbstractSimpleIdentifiable<ParserNamespace<K, V>> {
public enum StorageNodeType {
/**
/**
* Get a namespace behavior.
*
- * @param type Namespace type class
+ * @param type Namespace type
* @param <K> key type
* @param <V> value type
- * @param <N> namespace type
* @return Namespace behaviour
* @throws NamespaceNotAvailableException when the namespace is not available
*/
- <K, V, N extends ParserNamespace<K, V>> NamespaceBehaviour<K, V, N> getNamespaceBehaviour(N type);
+ <K, V> NamespaceBehaviour<K, V> getNamespaceBehaviour(ParserNamespace<K, V> type);
}
public interface NamespaceStorageNode {
@Nullable NamespaceStorageNode getParentNamespaceStorage();
- <K, V, N extends ParserNamespace<K, V>> @Nullable V getFromLocalStorage(N type, K key);
+ <K, V> @Nullable V getFromLocalStorage(ParserNamespace<K, V> type, K key);
- <K, V, N extends ParserNamespace<K, V>> @Nullable Map<K, V> getAllFromLocalStorage(N type);
+ <K, V> @Nullable Map<K, V> getAllFromLocalStorage(ParserNamespace<K, V> type);
/**
* Populate specified namespace with a key/value pair, overwriting previous contents. Similar to
* @param value Value
* @return Previously-stored value, or null if the key was not present
*/
- <K, V, N extends ParserNamespace<K, V>> @Nullable V putToLocalStorage(N type, K key, V value);
+ <K, V> @Nullable V putToLocalStorage(ParserNamespace<K, V> type, K key, V value);
/**
* Populate specified namespace with a key/value pair unless the key is already associated with a value. Similar
* @param value Value
* @return Preexisting value or null if there was no previous mapping
*/
- <K, V, N extends ParserNamespace<K, V>> @Nullable V putToLocalStorageIfAbsent(N type, K key, V value);
+ <K, V> @Nullable V putToLocalStorageIfAbsent(ParserNamespace<K, V> type, K key, V value);
}
/**
@Nullable StmtContext<QName, D, E> requestSchemaTreeChild(QName qname);
}
- protected NamespaceBehaviour(final N identifier) {
+ protected NamespaceBehaviour(final ParserNamespace<K, V> identifier) {
super(identifier);
}
* @param identifier Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
- * @param <N> type parameter
* @return global namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends ParserNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> global(
- final N identifier) {
+ public static <K, V> @NonNull NamespaceBehaviour<K, V> global(final ParserNamespace<K, V> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.GLOBAL);
}
* @param identifier Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
- * @param <N> type parameter
* @return source-local namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends ParserNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> sourceLocal(
- final N identifier) {
+ public static <K, V> @NonNull NamespaceBehaviour<K, V> sourceLocal(final ParserNamespace<K, V> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.SOURCE_LOCAL_SPECIAL);
}
- public static <K, V, N extends ParserNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> statementLocal(
- final N identifier) {
+ public static <K, V> @NonNull NamespaceBehaviour<K, V> statementLocal(final ParserNamespace<K, V> identifier) {
return new StatementLocal<>(identifier);
}
* @param identifier Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
- * @param <N> type parameter
* @return root-statement-local namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends ParserNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> rootStatementLocal(
- final N identifier) {
+ public static <K, V> @NonNull NamespaceBehaviour<K, V> rootStatementLocal(final ParserNamespace<K, V> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.ROOT_STATEMENT_LOCAL);
}
* Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
- * @param <N> type parameter
* @return tree-scoped namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends ParserNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> treeScoped(
- final N identifier) {
+ public static <K, V> @NonNull NamespaceBehaviour<K, V> treeScoped(final ParserNamespace<K, V> identifier) {
return new TreeScoped<>(identifier);
}
storage.putToLocalStorage(getIdentifier(), key, value);
}
- abstract static class AbstractSpecific<K, V, N extends ParserNamespace<K, V>> extends NamespaceBehaviour<K, V, N> {
- AbstractSpecific(final N identifier) {
+ abstract static class AbstractSpecific<K, V> extends NamespaceBehaviour<K, V> {
+ AbstractSpecific(final ParserNamespace<K, V> identifier) {
super(identifier);
}
abstract NamespaceStorageNode findStorageNode(NamespaceStorageNode storage);
}
- static final class StatementLocal<K, V, N extends ParserNamespace<K, V>> extends AbstractSpecific<K, V, N> {
- StatementLocal(final N identifier) {
+ static final class StatementLocal<K, V> extends AbstractSpecific<K, V> {
+ StatementLocal(final ParserNamespace<K, V> identifier) {
super(identifier);
}
}
}
- static final class StorageSpecific<K, V, N extends ParserNamespace<K, V>> extends AbstractSpecific<K, V, N> {
+ static final class StorageSpecific<K, V> extends AbstractSpecific<K, V> {
private final StorageNodeType storageType;
- StorageSpecific(final N identifier, final StorageNodeType type) {
+ StorageSpecific(final ParserNamespace<K, V> identifier, final StorageNodeType type) {
super(identifier);
storageType = requireNonNull(type);
}
}
}
- static final class TreeScoped<K, V, N extends ParserNamespace<K, V>> extends NamespaceBehaviour<K, V, N> {
- TreeScoped(final N identifier) {
+ static final class TreeScoped<K, V> extends NamespaceBehaviour<K, V> {
+ TreeScoped(final ParserNamespace<K, V> identifier) {
super(identifier);
}
*
* @param <K> namespace key type
* @param <V> namespace value type
- * @param <N> namespace type
* @param nsType namespace type class
* @return Namespace contents, if available
*/
- <K, V, N extends ParserNamespace<K, V>> @Nullable Map<K, V> namespace(@NonNull N nsType);
+ <K, V> @Nullable Map<K, V> namespace(@NonNull ParserNamespace<K, V> nsType);
/**
* Return a value associated with specified key within a namespace.
* @param key Key
* @param <K> namespace key type
* @param <V> namespace value type
- * @param <N> namespace type
* @param <T> key type
* @return Value, or null if there is no element
* @throws NamespaceNotAvailableException when the namespace is not available.
*/
- <K, V, T extends K, N extends ParserNamespace<K, V>> @Nullable V namespaceItem(@NonNull N nsType, T key);
+ <K, V, T extends K> @Nullable V namespaceItem(@NonNull ParserNamespace<K, V> nsType, T key);
/**
* Return the portion of specified namespace stored in this node. Depending on namespace behaviour this may or may
*
* @param <K> namespace key type
* @param <V> namespace value type
- * @param <N> namespace type
* @param nsType namespace type class
* @return Namespace portion stored in this node, if available
*/
- <K, V, N extends ParserNamespace<K, V>> @Nullable Map<K, V> localNamespacePortion(@NonNull N nsType);
+ <K, V> @Nullable Map<K, V> localNamespacePortion(@NonNull ParserNamespace<K, V> nsType);
/**
* Return the selected namespace.
*
* @param <K> namespace key type
* @param <V> namespace value type
- * @param <N> namespace type
* @param nsType namespace type class
* @return Namespace contents, if available
*/
// TODO: migrate users away
- default <K, V, N extends ParserNamespace<K, V>> Map<K, V> getAllFromNamespace(final @NonNull N nsType) {
+ default <K, V> Map<K, V> getAllFromNamespace(final @NonNull ParserNamespace<K, V> nsType) {
return namespace(nsType);
}
* @param key Key
* @param <K> namespace key type
* @param <V> namespace value type
- * @param <N> namespace type
* @param <T> key type
* @return Value, or null if there is no element
* @throws NamespaceNotAvailableException when the namespace is not available.
*/
// TODO: migrate users away
- default <K, V, T extends K, N extends ParserNamespace<K, V>> @Nullable V getFromNamespace(
- final @NonNull N type, final T key) {
+ default <K, V, T extends K> @Nullable V getFromNamespace(final @NonNull ParserNamespace<K, V> type, final T key) {
return namespaceItem(type, key);
}
}
public static final @NonNull ParserNamespace<QName, StatementSupport<?, ?, ?>> NAMESPACE =
new ParserNamespace<>("statementDefinitions");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.global(NAMESPACE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.global(NAMESPACE);
private StatementDefinitions() {
// Hidden on purpose
private final StatementSupportBundle parent;
private final ImmutableMap<QName, StatementSupport<?, ?, ?>> commonDefinitions;
private final ImmutableTable<YangVersion, QName, StatementSupport<?, ?, ?>> versionSpecificDefinitions;
- private final ImmutableMap<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?, ?>> namespaceDefinitions;
+ private final ImmutableMap<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?>> namespaceDefinitions;
private final ImmutableSet<YangVersion> supportedVersions;
private StatementSupportBundle(final StatementSupportBundle parent,
final ImmutableSet<YangVersion> supportedVersions,
final ImmutableMap<QName, StatementSupport<?, ?, ?>> commonStatements,
- final ImmutableMap<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?, ?>> namespaces,
+ final ImmutableMap<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?>> namespaces,
final ImmutableTable<YangVersion, QName, StatementSupport<?, ?, ?>> versionSpecificStatements) {
this.parent = parent;
this.supportedVersions = supportedVersions;
return versionSpecificDefinitions;
}
- public ImmutableMap<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?, ?>> getNamespaceDefinitions() {
+ public ImmutableMap<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?>> getNamespaceDefinitions() {
return namespaceDefinitions;
}
@Override
@SuppressWarnings("unchecked")
- public <K, V, N extends ParserNamespace<K, V>> NamespaceBehaviour<K, V, N> getNamespaceBehaviour(
- final N namespace) {
- final NamespaceBehaviour<?, ?, ?> potential = namespaceDefinitions.get(namespace);
+ public <K, V> NamespaceBehaviour<K, V> getNamespaceBehaviour(final ParserNamespace<K, V> namespace) {
+ final NamespaceBehaviour<?, ?> potential = namespaceDefinitions.get(namespace);
if (potential != null) {
checkState(namespace.equals(potential.getIdentifier()));
// Safe cast, previous checkState checks equivalence of key from which type argument are derived
- return (NamespaceBehaviour<K, V, N>) potential;
+ return (NamespaceBehaviour<K, V>) potential;
}
if (parent != null) {
return parent.getNamespaceBehaviour(namespace);
private final Map<QName, StatementSupport<?, ?, ?>> commonStatements = new HashMap<>();
private final Table<YangVersion, QName, StatementSupport<?, ?, ?>> versionSpecificStatements =
HashBasedTable.create();
- private final Map<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?, ?>> namespaces = new HashMap<>();
+ private final Map<ParserNamespace<?, ?>, NamespaceBehaviour<?, ?>> namespaces = new HashMap<>();
private final ImmutableSet<YangVersion> supportedVersions;
private StatementSupportBundle parent;
return this;
}
- public @NonNull Builder addSupport(final NamespaceBehaviour<?, ? ,?> namespaceSupport) {
+ public @NonNull Builder addSupport(final NamespaceBehaviour<?, ?> namespaceSupport) {
final var identifier = namespaceSupport.getIdentifier();
checkState(!namespaces.containsKey(identifier));
checkState(!parent.hasNamespaceBehaviour(identifier));
* @param value value
* @param <K> namespace key type
* @param <V> namespace value type
- * @param <N> namespace 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, N extends ParserNamespace<K, V>> void addToNs(@NonNull N type, T key, U value);
+ <K, V, T extends K, U extends V> void addToNs(@NonNull ParserNamespace<K, V> type, T key, U value);
@Override
RootStmtContext.Mutable<?, ?, ?> getRoot();
* @param stmt
* to be added to namespace map
*/
- <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(@NonNull N namespace, KT key,
- StmtContext<?, ?, ?> stmt);
+ <K, KT extends K, Y extends DeclaredStatement<?>, Z extends EffectiveStatement<?, Y>> void addContext(
+ @NonNull StatementNamespace<K, Y, Z> namespace, KT key, StmtContext<?, Y, Z> stmt);
/**
* Set version of root statement context.
* {@link NamespaceBehaviour}s corresponding to {@link SourceParserNamespaces}.
*/
public final class SourceNamespaceBehaviours {
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BELONGSTO_PREFIX_TO_MODULECTX =
+ 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 =
+ 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 =
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAME_TO_QNAME =
NamespaceBehaviour.sourceLocal(SourceParserNamespaces.MODULE_NAME_TO_QNAME);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> IMPORTED_MODULE =
+ public static final @NonNull NamespaceBehaviour<?, ?> IMPORTED_MODULE =
NamespaceBehaviour.sourceLocal(SourceParserNamespaces.IMPORTED_MODULE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> INCLUDED_MODULE =
+ public static final @NonNull NamespaceBehaviour<?, ?> INCLUDED_MODULE =
NamespaceBehaviour.sourceLocal(SourceParserNamespaces.INCLUDED_MODULE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> MODULECTX_TO_QNAME =
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULECTX_TO_QNAME =
NamespaceBehaviour.global(SourceParserNamespaces.MODULECTX_TO_QNAME);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> INCLUDED_SUBMODULE_NAME_TO_MODULECTX =
+ 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 =
+ 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 =
+ public static final @NonNull NamespaceBehaviour<?, ?> IMPORT_PREFIX_TO_MODULECTX =
NamespaceBehaviour.rootStatementLocal(SourceParserNamespaces.IMPORT_PREFIX_TO_MODULECTX);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> MODULE_FOR_BELONGSTO =
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_FOR_BELONGSTO =
NamespaceBehaviour.global(SourceParserNamespaces.MODULE_FOR_BELONGSTO);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> SUPPORTED_FEATURES =
+ public static final @NonNull NamespaceBehaviour<?, ?> SUPPORTED_FEATURES =
NamespaceBehaviour.global(SourceParserNamespaces.SUPPORTED_FEATURES);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> PREFIX_TO_MODULE =
+ public static final @NonNull NamespaceBehaviour<?, ?> PREFIX_TO_MODULE =
NamespaceBehaviour.global(SourceParserNamespaces.PREFIX_TO_MODULE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> MODULES_DEVIATED_BY =
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULES_DEVIATED_BY =
NamespaceBehaviour.global(SourceParserNamespaces.MODULES_DEVIATED_BY);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> MODULE_NAMESPACE_TO_NAME =
+ 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 =
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULE_NAME_TO_NAMESPACE =
NamespaceBehaviour.global(SourceParserNamespaces.MODULE_NAME_TO_NAMESPACE);
- public static final @NonNull NamespaceBehaviour<?, ?, ?> MODULECTX_TO_SOURCE =
+ public static final @NonNull NamespaceBehaviour<?, ?> MODULECTX_TO_SOURCE =
NamespaceBehaviour.global(SourceParserNamespaces.MODULECTX_TO_SOURCE);
private SourceNamespaceBehaviours() {
public static final @NonNull ParserNamespace<ValidationBundleType, Collection<?>> NAMESPACE =
new ParserNamespace<>("validationBundles");
- public static final @NonNull NamespaceBehaviour<?, ?, ?> BEHAVIOUR = NamespaceBehaviour.global(NAMESPACE);
+ public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.global(NAMESPACE);
private ValidationBundles() {
// Hidden on purpose
Code Review / yangtools.git / commitdiff