Improve StatementContextBase.stream{Declared,Effective}

[yangtools.git] / parser / yang-parser-reactor / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / reactor / ReactorStmtCtx.java

diff --git a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReactorStmtCtx.java b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReactorStmtCtx.java
index 73aef53d66b7e140caba5424019ecadf95927450..a00b5446e56db4d2fbfd566267cc50fec0fd18af 100644 (file)
--- a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReactorStmtCtx.java
+++ b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReactorStmtCtx.java
@@ -34,6 +34,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
 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;
@@ -48,7 +49,6 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -236,8 +236,8 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
 
     @Override
     public final QName moduleName() {
-        final RootStatementContext<?, ?, ?> root = getRoot();
-        return QName.create(StmtContextUtils.getRootModuleQName(root), root.getRawArgument());
+        final var root = getRoot();
+        return QName.create(StmtContextUtils.getModuleQName(root), root.getRawArgument());
     }
 
     //
@@ -299,16 +299,12 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
 
     private String refString() {
         final int current = refcount;
-        switch (current) {
-            case REFCOUNT_DEFUNCT:
-                return "DEFUNCT";
-            case REFCOUNT_SWEEPING:
-                return "SWEEPING";
-            case REFCOUNT_SWEPT:
-                return "SWEPT";
-            default:
-                return String.valueOf(refcount);
-        }
+        return switch (current) {
+            case REFCOUNT_DEFUNCT -> "DEFUNCT";
+            case REFCOUNT_SWEEPING -> "SWEEPING";
+            case REFCOUNT_SWEPT -> "SWEPT";
+            default -> String.valueOf(refcount);
+        };
     }
 
     /**
@@ -325,25 +321,22 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
     //
 
     @Override
-    public final <K, V, T extends K, N extends ParserNamespace<K, V>> V namespaceItem(final Class<@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 Class<@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 Class<@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 Class<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);
     }
 
@@ -409,8 +402,8 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
      * @return Built effective stateue
      */
     abstract @NonNull E createInferredEffective(@NonNull StatementFactory<A, D, E> factory,
-        @NonNull InferredStatementContext<A, D, E> ctx, Stream<? extends StmtContext<?, ?, ?>> declared,
-        Stream<? extends StmtContext<?, ?, ?>> effective);
+        @NonNull InferredStatementContext<A, D, E> ctx, Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+        Stream<? extends ReactorStmtCtx<?, ?, ?>> effective);
 
     /**
      * Attach an effective copy of this statement. This essentially acts as a map, where we make a few assumptions:
@@ -472,8 +465,9 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
     //
     //
 
+    // Non-final form ImplicitStmtCtx
     @Override
-    public final boolean isSupportedToBuildEffective() {
+    public boolean isSupportedToBuildEffective() {
         return isSupportedToBuildEffective;
     }
 
@@ -498,7 +492,8 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
          */
         if (isParentSupportedByFeatures()) {
             // If the set of supported features has not been provided, all features are supported by default.
-            final Set<QName> supportedFeatures = getFromNamespace(SupportedFeaturesNamespace.class, Empty.value());
+            final Set<QName> supportedFeatures = getFromNamespace(ParserNamespaces.SUPPORTED_FEATURES,
+                Empty.value());
             if (supportedFeatures == null || StmtContextUtils.checkFeatureSupport(this, supportedFeatures)) {
                 flags |= SET_SUPPORTED_BY_FEATURES;
                 return true;
@@ -656,17 +651,17 @@ abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends Effec
         }
 
         final Object argument = argument();
-        if (argument instanceof QName) {
-            return ((QName) argument).getModule();
+        if (argument instanceof QName qname) {
+            return qname.getModule();
         }
-        if (argument instanceof String) {
+        if (argument instanceof String str) {
             // FIXME: This may yield illegal argument exceptions
-            return StmtContextUtils.qnameFromArgument(getOriginalCtx().orElse(this), (String) argument).getModule();
+            return StmtContextUtils.qnameFromArgument(getOriginalCtx().orElse(this), str).getModule();
         }
-        if (argument instanceof SchemaNodeIdentifier
+        if (argument instanceof SchemaNodeIdentifier sni
                 && (producesDeclared(AugmentStatement.class) || producesDeclared(RefineStatement.class)
                         || producesDeclared(DeviationStatement.class))) {
-            return ((SchemaNodeIdentifier) argument).lastNodeIdentifier().getModule();
+            return sni.lastNodeIdentifier().getModule();
         }
 
         return coerceParent().effectiveNamespace();