Clarify StatementFactory.createEffective()

[yangtools.git] / yang / yang-parser-spi / src / main / java / org / opendaylight / yangtools / yang / parser / spi / meta / ForwardingStatementSupport.java

diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java
index 1e8eca6b2c0d2c531824b32654abdfdbf54d2e8c..61f30ed0c8813320280e3d9831cd1c73a84d79a8 100644 (file)
--- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java
+++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java
@@ -8,12 +8,9 @@
 package org.opendaylight.yangtools.yang.parser.spi.meta;
 
 import com.google.common.annotations.Beta;
-import com.google.common.collect.ForwardingObject;
 import java.util.stream.Stream;
-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.EffectiveStmtCtx.Current;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 
@@ -29,71 +26,78 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  */
 @Beta
 public abstract class ForwardingStatementSupport<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
-    extends ForwardingObject implements StatementSupport<A, D, E> {
+        extends StatementSupport<A, D, E> {
+    private final StatementSupport<A, D, E> delegate;
 
-    @Override
-    protected abstract StatementSupport<A, D, E> delegate();
+    protected ForwardingStatementSupport(final StatementSupport<A, D, E> delegate) {
+        super(delegate);
+        this.delegate = delegate;
+    }
 
     @Override
     public D createDeclared(final StmtContext<A, D, ?> ctx) {
-        return delegate().createDeclared(ctx);
+        return delegate.createDeclared(ctx);
     }
 
     @Override
     public E createEffective(final Current<A, D> stmt,
             final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
-            final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
-        return delegate().createEffective(stmt, declaredSubstatements, effectiveSubstatements);
+            final Stream<? extends StmtContext<?, ?, ?>> inferredSubstatements) {
+        return delegate.createEffective(stmt, declaredSubstatements, inferredSubstatements);
     }
 
     @Override
-    public StatementDefinition getPublicView() {
-        return delegate().getPublicView();
+    public E copyEffective(final Current<A, D> stmt, final E original) {
+        return delegate.copyEffective(stmt, original);
     }
 
     @Override
     public A parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
-        return delegate().parseArgumentValue(ctx, value);
+        return delegate.parseArgumentValue(ctx, value);
     }
 
     @Override
     public void onStatementAdded(final Mutable<A, D, E> stmt) {
-        delegate().onStatementAdded(stmt);
+        delegate.onStatementAdded(stmt);
     }
 
     @Override
     public void onPreLinkageDeclared(final Mutable<A, D, E> stmt) {
-        delegate().onPreLinkageDeclared(stmt);
+        delegate.onPreLinkageDeclared(stmt);
     }
 
     @Override
     public void onLinkageDeclared(final Mutable<A, D, E> stmt) {
-        delegate().onLinkageDeclared(stmt);
+        delegate.onLinkageDeclared(stmt);
     }
 
     @Override
     public void onStatementDefinitionDeclared(final Mutable<A, D, E> stmt) {
-        delegate().onStatementDefinitionDeclared(stmt);
+        delegate.onStatementDefinitionDeclared(stmt);
     }
 
     @Override
     public void onFullDefinitionDeclared(final Mutable<A, D, E> stmt) {
-        delegate().onFullDefinitionDeclared(stmt);
+        delegate.onFullDefinitionDeclared(stmt);
     }
 
     @Override
     public boolean hasArgumentSpecificSupports() {
-        return delegate().hasArgumentSpecificSupports();
+        return delegate.hasArgumentSpecificSupports();
     }
 
     @Override
     public StatementSupport<?, ?, ?> getSupportSpecificForArgument(final String argument) {
-        return delegate().getSupportSpecificForArgument(argument);
+        return delegate.getSupportSpecificForArgument(argument);
+    }
+
+    @Override
+    protected SubstatementValidator getSubstatementValidator() {
+        return delegate.getSubstatementValidator();
     }
 
     @Override
-    public CopyPolicy applyCopyPolicy(final Mutable<?, ?, ?> stmt, final Mutable<?, ?, ?> parent,
-            final CopyType copyType, final QNameModule targetModule) {
-        return delegate().applyCopyPolicy(stmt, parent, copyType, targetModule);
+    public String toString() {
+        return delegate.toString();
     }
 }