Do not force materialization when not needed
[yangtools.git] / yang / yang-parser-spi / src / main / java / org / opendaylight / yangtools / yang / parser / spi / meta / ForwardingStatementSupport.java
1 /*
2  * Copyright (c) 2017 Pantheon Technologies s.r.o. and others. All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.yangtools.yang.parser.spi.meta;
9
10 import com.google.common.annotations.Beta;
11 import com.google.common.collect.ForwardingObject;
12 import java.util.Collection;
13 import java.util.stream.Stream;
14 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
15 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
16 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
17 import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
18 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
19
20 /**
21  * Utility forwarding implementation of {@link StatementSupport} contract. This class is useful for implementing
22  * wrapped statements.
23  *
24  * @author Robert Varga
25  *
26  * @param <A> Argument type
27  * @param <D> Declared Statement representation
28  * @param <E> Effective Statement representation
29  */
30 @Beta
31 public abstract class ForwardingStatementSupport<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
32     extends ForwardingObject implements StatementSupport<A, D, E> {
33
34     @Override
35     protected abstract StatementSupport<A, D, E> delegate();
36
37     @Override
38     public D createDeclared(final StmtContext<A, D, ?> ctx) {
39         return delegate().createDeclared(ctx);
40     }
41
42     @Override
43     public E createEffective(final Current<A, D> stmt,
44             final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
45             final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
46         return delegate().createEffective(stmt, declaredSubstatements, effectiveSubstatements);
47     }
48
49     @Override
50     public StatementDefinition getPublicView() {
51         return delegate().getPublicView();
52     }
53
54     @Override
55     public A parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
56         return delegate().parseArgumentValue(ctx, value);
57     }
58
59     @Override
60     public void onStatementAdded(final Mutable<A, D, E> stmt) {
61         delegate().onStatementAdded(stmt);
62     }
63
64     @Override
65     public void onPreLinkageDeclared(final Mutable<A, D, E> stmt) {
66         delegate().onPreLinkageDeclared(stmt);
67     }
68
69     @Override
70     public void onLinkageDeclared(final Mutable<A, D, E> stmt) {
71         delegate().onLinkageDeclared(stmt);
72     }
73
74     @Override
75     public void onStatementDefinitionDeclared(final Mutable<A, D, E> stmt) {
76         delegate().onStatementDefinitionDeclared(stmt);
77     }
78
79     @Override
80     public void onFullDefinitionDeclared(final Mutable<A, D, E> stmt) {
81         delegate().onFullDefinitionDeclared(stmt);
82     }
83
84     @Override
85     public boolean hasArgumentSpecificSupports() {
86         return delegate().hasArgumentSpecificSupports();
87     }
88
89     @Override
90     public StatementSupport<?, ?, ?> getSupportSpecificForArgument(final String argument) {
91         return delegate().getSupportSpecificForArgument(argument);
92     }
93
94     @Override
95     public CopyPolicy copyPolicy() {
96         return delegate().copyPolicy();
97     }
98
99     @Override
100     public boolean canReuseCurrent(final Current<A, D> copy, final Current<A, D> current,
101             final Collection<? extends EffectiveStatement<?, ?>> substatements) {
102         return delegate().canReuseCurrent(copy, current, substatements);
103     }
104 }