Improve StatementContextBase.stream{Declared,Effective}

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

diff --git a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java
index 38f42ad8296421953bcbb8a509826e0e9332f9d8..d37cd34b0c5703bec8d915ff9c9a527a4f30134f 100644 (file)
--- a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java
+++ b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java
@@ -225,8 +225,8 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
 
     @Override
     E createInferredEffective(final StatementFactory<A, D, E> factory, final InferredStatementContext<A, D, E> ctx,
-            final Stream<? extends StmtContext<?, ?, ?>> declared,
-            final Stream<? extends StmtContext<?, ?, ?>> effective) {
+            final Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+            final Stream<? extends ReactorStmtCtx<?, ?, ?>> effective) {
         return originalCtx.createInferredEffective(factory, ctx, declared, effective);
     }
 
@@ -259,11 +259,11 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
 
         // ... copy-sensitive check
         final List<EffectiveCopy> declCopy = prototype.streamDeclared()
-            .map(sub -> effectiveCopy((ReactorStmtCtx<?, ?, ?>) sub))
+            .map(this::effectiveCopy)
             .filter(Objects::nonNull)
             .collect(Collectors.toUnmodifiableList());
         final List<EffectiveCopy> effCopy = prototype.streamEffective()
-            .map(sub -> effectiveCopy((ReactorStmtCtx<?, ?, ?>) sub))
+            .map(this::effectiveCopy)
             .filter(Objects::nonNull)
             .collect(Collectors.toUnmodifiableList());
 
@@ -329,10 +329,10 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         return reusePrototypeReplicas(Streams.concat(prototype.streamDeclared(), prototype.streamEffective()));
     }
 
-    private List<ReactorStmtCtx<?, ?, ?>> reusePrototypeReplicas(final Stream<StmtContext<?, ?, ?>> stream) {
+    private List<ReactorStmtCtx<?, ?, ?>> reusePrototypeReplicas(final Stream<ReactorStmtCtx<?, ?, ?>> stream) {
         return stream
             .map(stmt -> {
-                final ReplicaStatementContext<?, ?, ?> ret = ((ReactorStmtCtx<?, ?, ?>) stmt).replicaAsChildOf(this);
+                final var ret = stmt.replicaAsChildOf(this);
                 ret.buildEffective();
                 return ret;
             })
@@ -340,19 +340,18 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
     }
 
     private static boolean sameSubstatements(final Collection<?> original, final EffectiveStatement<?, ?> effective) {
-        final Collection<?> copied = effective.effectiveSubstatements();
+        final var copied = effective.effectiveSubstatements();
         if (copied != effective.effectiveSubstatements() || original.size() != copied.size()) {
             // Do not bother if result is treating substatements as transient
             return false;
         }
 
-        final Iterator<?> oit = original.iterator();
-        final Iterator<?> cit = copied.iterator();
-        while (oit.hasNext()) {
+        final var cit = copied.iterator();
+        for (var origChild : original) {
             verify(cit.hasNext());
             // Identity comparison on purpose to side-step whatever equality there might be. We want to reuse instances
             // after all.
-            if (oit.next() != cit.next()) {
+            if (origChild != cit.next()) {
                 return false;
             }
         }
@@ -461,9 +460,8 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         }
 
         @SuppressWarnings("unchecked")
-        final Mutable<QName, Y, Z> ret = (Mutable<QName, Y, Z>) copySubstatement((Mutable<?, ?, ?>) template)
-            .orElseThrow(
-                () -> new InferenceException(this, "Failed to materialize child %s template %s", qname, template));
+        final var ret = (Mutable<QName, Y, Z>) copySubstatement(template).orElseThrow(
+            () -> new InferenceException(this, "Failed to materialize child %s template %s", qname, template));
         addMaterialized(template, ensureCompletedPhase(ret));
 
         LOG.debug("Child {} materialized", qname);
@@ -495,12 +493,12 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
     }
 
     @Override
-    Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
+    Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamDeclared() {
         return Stream.empty();
     }
 
     @Override
-    Stream<? extends @NonNull StmtContext<?, ?, ?>> streamEffective() {
+    Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamEffective() {
         return ensureEffectiveSubstatements().stream().filter(StmtContext::isSupportedToBuildEffective);
     }
 
@@ -593,7 +591,8 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         }
     }
 
-    private Optional<? extends Mutable<?, ?, ?>> copySubstatement(final Mutable<?, ?, ?> substatement) {
+    private <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>> Optional<Mutable<X, Y, Z>>
+            copySubstatement(final StmtContext<X, Y, Z> substatement) {
         return substatement.copyAsChildOf(this, childCopyType(), targetModule);
     }