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

   1 /*
   2  * Copyright (c) 2021 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 com.google.common.base.Verify.verify;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.collect.ImmutableList;
  14 import java.util.Collection;
  15 import java.util.stream.Stream;
  16 import org.eclipse.jdt.annotation.NonNull;
  17 import org.eclipse.jdt.annotation.Nullable;
  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.CopyType;
  21 import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.UndeclaredCurrent;
  22 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
  23 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementFactory;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
  25 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  26 import org.opendaylight.yangtools.yang.parser.spi.meta.UndeclaredStatementFactory;
  27 import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement;
  28
  29 /**
  30 /**
  31  * Core reactor statement implementation of {@link Mutable}.
  32  *
  33  * @param <A> Argument type
  34  * @param <D> Declared Statement representation
  35  * @param <E> Effective Statement representation
  36  */
  37 final class UndeclaredStmtCtx<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
  38         extends OriginalStmtCtx<A, D, E> implements UndeclaredCurrent<A, D> {
  39     private final StatementContextBase<?, ?, ?> parent;
  40     private final A argument;
  41
  42     private UndeclaredStmtCtx(final UndeclaredStmtCtx<A, D, E> original, final StatementContextBase<?, ?, ?> parent) {
  43         super(original);
  44         this.parent = requireNonNull(parent);
  45         this.argument = original.argument;
  46     }
  47
  48     UndeclaredStmtCtx(final StatementContextBase<?, ?, ?> parent, final StatementSupport<A, D, E> support,
  49             final @Nullable A argument) {
  50         super(new StatementDefinitionContext<>(support), ImplicitSubstatement.of(parent.sourceReference()));
  51         this.parent = requireNonNull(parent);
  52         this.argument = argument != null ? argument : definition().parseArgumentValue(this, null);
  53     }
  54
  55     // Exposed for StatementContextBase.wrapWithImplicit()
  56     UndeclaredStmtCtx(final StatementContextBase<?, ?, ?> original, final StatementSupport<A, D, E> support) {
  57         super(new StatementDefinitionContext<>(verifySupport(support)), original.sourceReference(),
  58             original.getLastOperation());
  59         this.parent = original.getParentContext();
  60         this.argument = castArgument(original);
  61     }
  62
  63     // Exposed for implicit substatement wrapping in StatementContextBase.childCopyOf()
  64     UndeclaredStmtCtx(final StatementContextBase<?, ?, ?> parent, final StatementSupport<A, D, E> support,
  65             final StatementContextBase<?, ?, ?> original, final CopyType type) {
  66         super(new StatementDefinitionContext<>(verifySupport(support)), original.sourceReference(), type);
  67         this.parent = requireNonNull(parent);
  68         this.argument = castArgument(original);
  69     }
  70
  71     // Exposed for AbstractResumedStatement
  72     UndeclaredStmtCtx(final StatementContextBase<?, ?, ?> parent, final StatementSupport<A, D, E> support,
  73             final String rawArgument) {
  74         super(new StatementDefinitionContext<>(support), ImplicitSubstatement.of(parent.sourceReference()));
  75         this.parent = requireNonNull(parent);
  76         this.argument = definition().parseArgumentValue(this, rawArgument);
  77     }
  78
  79     // FIXME: this assumes original's argument type matches this type... which is true for the only case we
  80     //        currently care about (implicit case in choice, which is always triggered by a SchemaTree original),
  81     //        but this will need re-visiting
  82     @SuppressWarnings("unchecked")
  83     private static <A> @NonNull A castArgument(final StatementContextBase<?, ?, ?> original) {
  84         return (A) original.getArgument();
  85     }
  86
  87     private static <T> T verifySupport(final T support) {
  88         verify(support instanceof UndeclaredStatementFactory, "Unexpected statement support %s", support);
  89         return support;
  90     }
  91
  92     @Override
  93     public Collection<? extends StatementContextBase<?, ?, ?>> mutableDeclaredSubstatements() {
  94         return ImmutableList.of();
  95     }
  96
  97     @Override
  98     Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
  99         return Stream.empty();
 100     }
 101
 102     @Override
 103     void dropDeclaredSubstatements() {
 104         // No-op
 105     }
 106
 107     @Override
 108     UndeclaredStmtCtx<A, D, E> reparent(final StatementContextBase<?, ?, ?> newParent) {
 109         return new UndeclaredStmtCtx<>(this, newParent);
 110     }
 111
 112     @Override
 113     E createEffective(final StatementFactory<A, D, E> factory) {
 114         return createEffective(factory, this, streamEffective());
 115     }
 116
 117     @SuppressWarnings("unchecked")
 118     private static <A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> @NonNull E createEffective(
 119             final @NonNull StatementFactory<A, D, E> factory, final @NonNull UndeclaredCurrent<A, D> ctx,
 120             final @NonNull Stream<? extends StmtContext<?, ?, ?>> substatements) {
 121         verify(factory instanceof UndeclaredStatementFactory, "Unexpected factory %s", factory);
 122         return ((UndeclaredStatementFactory<A, D, E>) factory).createUndeclaredEffective(ctx, substatements);
 123     }
 124
 125     @Override
 126     E createInferredEffective(final StatementFactory<A, D, E> factory, final InferredStatementContext<A, D, E> ctx,
 127             final Stream<? extends StmtContext<?, ?, ?>> declared,
 128             final Stream<? extends StmtContext<?, ?, ?>> effective) {
 129         final long declaredCount = declared.count();
 130         verify(declaredCount == 0, "Unexpected non-empty declared statements in %s", ctx);
 131         return createEffective(factory, new ForwardingUndeclaredCurrent<>(ctx), effective);
 132     }
 133
 134     /*
 135      * KEEP THINGS ORGANIZED!
 136      *
 137      * below methods exist in the same form in InferredStatementContext. If any adjustment is made here, make sure it is
 138      * properly updated there.
 139      */
 140     @Override
 141     public A argument() {
 142         return argument;
 143     }
 144
 145     @Override
 146     public StatementContextBase<?, ?, ?> getParentContext() {
 147         return parent;
 148     }
 149
 150     @Override
 151     public StorageNodeType getStorageNodeType() {
 152         return StorageNodeType.STATEMENT_LOCAL;
 153     }
 154
 155     @Override
 156     public StatementContextBase<?, ?, ?> getParentNamespaceStorage() {
 157         return parent;
 158     }
 159
 160     @Override
 161     public RootStatementContext<?, ?, ?> getRoot() {
 162         return parent.getRoot();
 163     }
 164
 165     @Override
 166     public EffectiveConfig effectiveConfig() {
 167         return effectiveConfig(parent);
 168     }
 169
 170     @Override
 171     protected boolean isIgnoringIfFeatures() {
 172         return isIgnoringIfFeatures(parent);
 173     }
 174
 175     @Override
 176     protected boolean isIgnoringConfig() {
 177         return isIgnoringConfig(parent);
 178     }
 179
 180     @Override
 181     protected boolean isParentSupportedByFeatures() {
 182         return parent.isSupportedByFeatures();
 183     }
 184 }