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

   1 /*
   2  * Copyright (c) 2020 PANTHEON.tech, 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.stmt.reactor;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import java.util.Collection;
  13 import java.util.List;
  14 import java.util.Optional;
  15 import java.util.stream.Stream;
  16 import org.opendaylight.yangtools.yang.common.QNameModule;
  17 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  18 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  19 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  20 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
  21 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
  22 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
  23 import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementFactory;
  25 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
  26 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
  27 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  28 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  29
  30 /**
  31  * A replica of a different statement. It does not allow modification, but produces an effective statement from a
  32  * designated source.
  33  */
  34 final class ReplicaStatementContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
  35         extends ReactorStmtCtx<A, D, E> {
  36     private final StatementContextBase<?, ?, ?> parent;
  37     private final ReactorStmtCtx<A, D, E> source;
  38
  39     ReplicaStatementContext(final StatementContextBase<?, ?, ?> parent, final ReactorStmtCtx<A, D, E> source) {
  40         super(source, null);
  41         this.parent = requireNonNull(parent);
  42         this.source = requireNonNull(source);
  43         if (source.isSupportedToBuildEffective()) {
  44             source.incRef();
  45         }
  46     }
  47
  48     @Override
  49     E createEffective() {
  50         return source.buildEffective();
  51     }
  52
  53     @Override
  54     E createInferredEffective(final StatementFactory<A, D, E> factory, final InferredStatementContext<A, D, E> ctx,
  55             final Stream<? extends StmtContext<?, ?, ?>> declared,
  56             final Stream<? extends StmtContext<?, ?, ?>> effective) {
  57         return source.createInferredEffective(factory, ctx, declared, effective);
  58     }
  59
  60     @Override
  61     ReactorStmtCtx<A, D, E> unmodifiedEffectiveSource() {
  62         return source.unmodifiedEffectiveSource();
  63     }
  64
  65     @Override
  66     public EffectiveConfig effectiveConfig() {
  67         return source.effectiveConfig();
  68     }
  69
  70     @Override
  71     public D declared() {
  72         return source.declared();
  73     }
  74
  75     @Override
  76     public A argument() {
  77         return source.argument();
  78     }
  79
  80     @Override
  81     public StatementSourceReference sourceReference() {
  82         return source.sourceReference();
  83     }
  84
  85     @Override
  86     public String rawArgument() {
  87         return source.rawArgument();
  88     }
  89
  90     @Override
  91     public Optional<StmtContext<A, D, E>> getOriginalCtx() {
  92         return source.getOriginalCtx();
  93     }
  94
  95     @Override
  96     public Collection<? extends StatementContextBase<?, ?, ?>> mutableDeclaredSubstatements() {
  97         return source.mutableDeclaredSubstatements();
  98     }
  99
 100     @Override
 101     public Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements() {
 102         return source.mutableEffectiveSubstatements();
 103     }
 104
 105     @Override
 106     byte executionOrder() {
 107         return source.executionOrder();
 108     }
 109
 110     @Override
 111     public CopyHistory history() {
 112         return source.history();
 113     }
 114
 115     @Override
 116     public Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement() {
 117         return List.of();
 118     }
 119
 120     @Override
 121     ReplicaStatementContext<A, D, E> replicaAsChildOf(final StatementContextBase<?, ?, ?> newParent) {
 122         return source.replicaAsChildOf(newParent);
 123     }
 124
 125     @Override
 126     public Optional<? extends Mutable<?, ?, ?>> copyAsChildOf(final Mutable<?, ?, ?> newParent, final CopyType type,
 127             final QNameModule targetModule) {
 128         return source.copyAsChildOf(newParent, type, targetModule);
 129     }
 130
 131     @Override
 132     ReactorStmtCtx<?, ?, ?> asEffectiveChildOf(final StatementContextBase<?, ?, ?> newParent, final CopyType type,
 133             final QNameModule targetModule) {
 134         final ReactorStmtCtx<?, ?, ?> ret = source.asEffectiveChildOf(newParent, type, targetModule);
 135         return ret == null ? null : this;
 136     }
 137
 138     @Override
 139     StatementDefinitionContext<A, D, E> definition() {
 140         return source.definition();
 141     }
 142
 143     @Override
 144     void markNoParentRef() {
 145         // No-op
 146     }
 147
 148     @Override
 149     int sweepSubstatements() {
 150         if (haveSourceReference()) {
 151             source.decRef();
 152         }
 153         return 0;
 154     }
 155
 156     @Override
 157     @Deprecated
 158     public <K, V, T extends K, U extends V> void addToNs(final ParserNamespace<K, V> type, final T key, final U value) {
 159         throw new UnsupportedOperationException();
 160     }
 161
 162     @Override
 163     @Deprecated
 164     public Optional<StmtContext<A, D, E>> getPreviousCopyCtx() {
 165         throw new UnsupportedOperationException();
 166     }
 167
 168     @Override
 169     @Deprecated
 170     public <K, KT extends K, Y extends DeclaredStatement<?>, Z extends EffectiveStatement<?, Y>> void addContext(
 171             final StatementNamespace<K, Y, Z> namespace, final KT key, final StmtContext<?, Y, Z> stmt) {
 172         throw new UnsupportedOperationException();
 173     }
 174
 175     @Override
 176     @Deprecated
 177     public void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
 178         throw new UnsupportedOperationException();
 179     }
 180
 181     @Override
 182     @Deprecated
 183     public Mutable<?, ?, ?> childCopyOf(final StmtContext<?, ?, ?> stmt, final CopyType type,
 184             final QNameModule targetModule) {
 185         throw new UnsupportedOperationException();
 186     }
 187
 188     @Override
 189     @Deprecated
 190     boolean doTryToCompletePhase(final byte executionOrder) {
 191         throw new UnsupportedOperationException();
 192     }
 193
 194     @Override
 195     @Deprecated
 196     public <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>>
 197             Mutable<X, Y, Z> createUndeclaredSubstatement(final StatementSupport<X, Y, Z> support, final X arg) {
 198         throw new UnsupportedOperationException();
 199     }
 200
 201     @Override
 202     @Deprecated
 203     public void addEffectiveSubstatement(final Mutable<?, ?, ?> substatement) {
 204         throw new UnsupportedOperationException();
 205     }
 206
 207     @Override
 208     @Deprecated
 209     public void addEffectiveSubstatements(final Collection<? extends Mutable<?, ?, ?>> statements) {
 210         throw new UnsupportedOperationException();
 211     }
 212
 213     @Override
 214     @Deprecated
 215     public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef) {
 216         throw new UnsupportedOperationException();
 217     }
 218
 219     @Override
 220     @Deprecated
 221     public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef,
 222             final String statementArg) {
 223         throw new UnsupportedOperationException();
 224     }
 225
 226     @Override
 227     @Deprecated
 228     public boolean hasImplicitParentSupport() {
 229         throw new UnsupportedOperationException();
 230     }
 231
 232     @Override
 233     @Deprecated
 234     public StmtContext<?, ?, ?> wrapWithImplicit(final StmtContext<?, ?, ?> original) {
 235         throw new UnsupportedOperationException();
 236     }
 237
 238     /*
 239      * KEEP THINGS ORGANIZED!
 240      *
 241      * below methods exist in the same form in InferredStatementContext/SubstatementContext. If any adjustment is made
 242      * here, make sure it is properly updated there.
 243      */
 244     @Override
 245     public StatementContextBase<?, ?, ?> getParentContext() {
 246         return parent;
 247     }
 248
 249     @Override
 250     public StorageNodeType getStorageNodeType() {
 251         return StorageNodeType.STATEMENT_LOCAL;
 252     }
 253
 254     @Override
 255     public StatementContextBase<?, ?, ?> getParentNamespaceStorage() {
 256         return parent;
 257     }
 258
 259     @Override
 260     public RootStatementContext<?, ?, ?> getRoot() {
 261         return parent.getRoot();
 262     }
 263
 264     @Override
 265     protected boolean isIgnoringIfFeatures() {
 266         return isIgnoringIfFeatures(parent);
 267     }
 268
 269     @Override
 270     protected boolean isIgnoringConfig() {
 271         return isIgnoringConfig(parent);
 272     }
 273
 274     @Override
 275     protected boolean isParentSupportedByFeatures() {
 276         return parent.isSupportedByFeatures();
 277     }
 278 }