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