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 org.eclipse.jdt.annotation.NonNull;
  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.parser.spi.meta.CopyHistory;
  20 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
  21 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
  22 import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
  23 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  25 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  26
  27 /**
  28  * A replica of a different statement. It does not allow modification, but produces an effective statement from a
  29  * designated source.
  30  */
  31 final class ReplicaStatementContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
  32         extends ReactorStmtCtx<A, D, E> {
  33     private final StatementContextBase<?, ?, ?> parent;
  34     private final ReactorStmtCtx<A, D, E> source;
  35
  36     ReplicaStatementContext(final StatementContextBase<?, ?, ?> parent, final ReactorStmtCtx<A, D, E> source) {
  37         super(source, null);
  38         this.parent = requireNonNull(parent);
  39         this.source = requireNonNull(source);
  40         if (source.isSupportedToBuildEffective()) {
  41             source.incRef();
  42         }
  43     }
  44
  45     @Override
  46     E createEffective() {
  47         return source.buildEffective();
  48     }
  49
  50     @Override
  51     ReactorStmtCtx<A, D, E> unmodifiedEffectiveSource() {
  52         return source.unmodifiedEffectiveSource();
  53     }
  54
  55     @Override
  56     public EffectiveConfig effectiveConfig() {
  57         return source.effectiveConfig();
  58     }
  59
  60     @Override
  61     public D declared() {
  62         return source.declared();
  63     }
  64
  65     @Override
  66     public A argument() {
  67         return source.argument();
  68     }
  69
  70     @Override
  71     public StatementSourceReference sourceReference() {
  72         return source.sourceReference();
  73     }
  74
  75     @Override
  76     public String rawArgument() {
  77         return source.rawArgument();
  78     }
  79
  80     @Override
  81     public Optional<StmtContext<A, D, E>> getOriginalCtx() {
  82         return source.getOriginalCtx();
  83     }
  84
  85     @Override
  86     public Collection<? extends StatementContextBase<?, ?, ?>> mutableDeclaredSubstatements() {
  87         return source.mutableDeclaredSubstatements();
  88     }
  89
  90     @Override
  91     public Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements() {
  92         return source.mutableEffectiveSubstatements();
  93     }
  94
  95     @Override
  96     byte executionOrder() {
  97         return source.executionOrder();
  98     }
  99
 100     @Override
 101     public CopyHistory history() {
 102         return source.history();
 103     }
 104
 105     @Override
 106     public Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement() {
 107         return List.of();
 108     }
 109
 110     @Override
 111     ReplicaStatementContext<A, D, E> replicaAsChildOf(final StatementContextBase<?, ?, ?> newParent) {
 112         return source.replicaAsChildOf(newParent);
 113     }
 114
 115     @Override
 116     public Optional<? extends Mutable<?, ?, ?>> copyAsChildOf(final Mutable<?, ?, ?> newParent, final CopyType type,
 117             final QNameModule targetModule) {
 118         return source.copyAsChildOf(newParent, type, targetModule);
 119     }
 120
 121     @Override
 122     ReactorStmtCtx<?, ?, ?> asEffectiveChildOf(final StatementContextBase<?, ?, ?> newParent, final CopyType type,
 123             final QNameModule targetModule) {
 124         final ReactorStmtCtx<?, ?, ?> ret = source.asEffectiveChildOf(newParent, type, targetModule);
 125         return ret == null ? null : this;
 126     }
 127
 128     @Override
 129     StatementDefinitionContext<A, D, E> definition() {
 130         return source.definition();
 131     }
 132
 133     @Override
 134     void markNoParentRef() {
 135         // No-op
 136     }
 137
 138     @Override
 139     int sweepSubstatements() {
 140         if (haveSourceReference()) {
 141             source.decRef();
 142         }
 143         return 0;
 144     }
 145
 146     @Override
 147     public <K, V, T extends K, U extends V, N extends ParserNamespace<K, V>> void addToNs(final Class<@NonNull N> type,
 148             final T key, final U value) {
 149         throw new UnsupportedOperationException();
 150     }
 151
 152     @Override
 153     public Optional<StmtContext<A, D, E>> getPreviousCopyCtx() {
 154         throw new UnsupportedOperationException();
 155     }
 156
 157     @Override
 158     public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final Class<@NonNull N> namespace,
 159             final KT key, final StmtContext<?, ?, ?> stmt) {
 160         throw new UnsupportedOperationException();
 161     }
 162
 163     @Override
 164     public void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
 165         throw new UnsupportedOperationException();
 166     }
 167
 168     @Override
 169     public Mutable<?, ?, ?> childCopyOf(final StmtContext<?, ?, ?> stmt, final CopyType type,
 170             final QNameModule targetModule) {
 171         throw new UnsupportedOperationException();
 172     }
 173
 174     @Override
 175     boolean doTryToCompletePhase(final byte executionOrder) {
 176         throw new UnsupportedOperationException();
 177     }
 178
 179     /*
 180      * KEEP THINGS ORGANIZED!
 181      *
 182      * below methods exist in the same form in InferredStatementContext/SubstatementContext. If any adjustment is made
 183      * here, make sure it is properly updated there.
 184      */
 185     @Override
 186     public StatementContextBase<?, ?, ?> getParentContext() {
 187         return parent;
 188     }
 189
 190     @Override
 191     public StorageNodeType getStorageNodeType() {
 192         return StorageNodeType.STATEMENT_LOCAL;
 193     }
 194
 195     @Override
 196     public StatementContextBase<?, ?, ?> getParentNamespaceStorage() {
 197         return parent;
 198     }
 199
 200     @Override
 201     public RootStatementContext<?, ?, ?> getRoot() {
 202         return parent.getRoot();
 203     }
 204
 205     @Override
 206     protected boolean isIgnoringIfFeatures() {
 207         return isIgnoringIfFeatures(parent);
 208     }
 209
 210     @Override
 211     protected boolean isIgnoringConfig() {
 212         return isIgnoringConfig(parent);
 213     }
 214
 215     @Override
 216     protected boolean isParentSupportedByFeatures() {
 217         return parent.isSupportedByFeatures();
 218     }
 219 }