Fix inferred statements over undeclared statements

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

diff --git a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReplicaStatementContext.java b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReplicaStatementContext.java
index 79add29f2e9800115971101d8eab1fce766faafb..16bab426be499d7a043ed85b9a8d89f427ba2b5e 100644 (file)
--- a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReplicaStatementContext.java
+++ b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReplicaStatementContext.java
@@ -12,15 +12,19 @@ import static java.util.Objects.requireNonNull;
 import java.util.Collection;
 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;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
 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.StatementFactory;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
 
@@ -47,6 +51,13 @@ final class ReplicaStatementContext<A, D extends DeclaredStatement<A>, E extends
         return source.buildEffective();
     }
 
+    @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) {
+        return source.createInferredEffective(factory, ctx, declared, effective);
+    }
+
     @Override
     ReactorStmtCtx<A, D, E> unmodifiedEffectiveSource() {
         return source.unmodifiedEffectiveSource();
@@ -144,38 +155,88 @@ final class ReplicaStatementContext<A, D extends DeclaredStatement<A>, E extends
     }
 
     @Override
+    @Deprecated
     public <K, V, T extends K, U extends V, N extends ParserNamespace<K, V>> void addToNs(final Class<@NonNull N> type,
             final T key, final U value) {
         throw new UnsupportedOperationException();
     }
 
     @Override
+    @Deprecated
     public Optional<StmtContext<A, D, E>> getPreviousCopyCtx() {
         throw new UnsupportedOperationException();
     }
 
     @Override
+    @Deprecated
     public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final Class<@NonNull N> namespace,
             final KT key, final StmtContext<?, ?, ?> stmt) {
         throw new UnsupportedOperationException();
     }
 
     @Override
+    @Deprecated
     public void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
         throw new UnsupportedOperationException();
     }
 
     @Override
+    @Deprecated
     public Mutable<?, ?, ?> childCopyOf(final StmtContext<?, ?, ?> stmt, final CopyType type,
             final QNameModule targetModule) {
         throw new UnsupportedOperationException();
     }
 
     @Override
+    @Deprecated
     boolean doTryToCompletePhase(final byte executionOrder) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    @Deprecated
+    public <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>>
+            Mutable<X, Y, Z> createUndeclaredSubstatement(final StatementSupport<X, Y, Z> support, final X arg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @Deprecated
+    public void addEffectiveSubstatement(final Mutable<?, ?, ?> substatement) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @Deprecated
+    public void addEffectiveSubstatements(final Collection<? extends Mutable<?, ?, ?>> statements) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @Deprecated
+    public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @Deprecated
+    public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef,
+            final String statementArg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @Deprecated
+    public boolean hasImplicitParentSupport() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @Deprecated
+    public StmtContext<?, ?, ?> wrapWithImplicit(final StmtContext<?, ?, ?> original) {
+        throw new UnsupportedOperationException();
+    }
+
     /*
      * KEEP THINGS ORGANIZED!
      *