parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.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 com.google.common.base.Preconditions.checkState;
  11 import static com.google.common.base.Verify.verify;
  12 import static com.google.common.base.Verify.verifyNotNull;
  13
  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.model.api.meta.StatementDefinition;
  21 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
  22 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementFactory;
  23 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  25 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  26 import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement;
  27
  28 /**
  29  * Intermediate subclass of StatementContextBase facing the parser stream via implementation of ResumedStatement. This
  30  * shields inference-type substatements from these details.
  31  *
  32  * @param <A> Argument type
  33  * @param <D> Declared Statement representation
  34  * @param <E> Effective Statement representation
  35  */
  36 abstract class AbstractResumedStatement<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
  37         extends OriginalStmtCtx<A, D, E> implements ResumedStatement {
  38     private final String rawArgument;
  39
  40     private StatementMap substatements = StatementMap.empty();
  41     private @Nullable D declaredInstance;
  42     private boolean implicitDeclared;
  43
  44     // Copy constructor
  45     AbstractResumedStatement(final AbstractResumedStatement<A, D, E> original) {
  46         super(original);
  47         this.rawArgument = original.rawArgument;
  48         this.substatements = original.substatements;
  49         this.declaredInstance = original.declaredInstance;
  50     }
  51
  52     AbstractResumedStatement(final StatementDefinitionContext<A, D, E> def, final StatementSourceReference ref,
  53             final String rawArgument) {
  54         super(def, ref);
  55         this.rawArgument = def.support().internArgument(rawArgument);
  56     }
  57
  58     @Override
  59     public final String rawArgument() {
  60         return rawArgument;
  61     }
  62
  63     @Override
  64     public Collection<? extends StatementContextBase<?, ?, ?>> mutableDeclaredSubstatements() {
  65         return verifyNotNull(substatements);
  66     }
  67
  68     @Override
  69     public final D declared() {
  70         final D existing;
  71         return (existing = declaredInstance) != null ? existing : loadDeclared();
  72     }
  73
  74     private @NonNull D loadDeclared() {
  75         final ModelProcessingPhase phase = getCompletedPhase();
  76         checkState(phase == ModelProcessingPhase.FULL_DECLARATION || phase == ModelProcessingPhase.EFFECTIVE_MODEL,
  77                 "Cannot build declared instance after phase %s", phase);
  78         return declaredInstance = definition().getFactory().createDeclared(this, substatementsAsDeclared());
  79     }
  80
  81     @SuppressWarnings({ "rawtypes", "unchecked" })
  82     private @NonNull Stream<DeclaredStatement<?>> substatementsAsDeclared() {
  83         final Stream<AbstractResumedStatement<?, ?, ?>> stream;
  84         if (implicitDeclared) {
  85             stream = substatements.stream().map(AbstractResumedStatement::unmaskUndeclared);
  86         } else {
  87             stream = (Stream) substatements.stream();
  88         }
  89
  90         return stream.map(AbstractResumedStatement::declared);
  91     }
  92
  93     @Override
  94     public final StatementDefinition getDefinition() {
  95         return publicDefinition();
  96     }
  97
  98     @Override
  99     public final StatementSourceReference getSourceReference() {
 100         return sourceReference();
 101     }
 102
 103     @Override
 104     public final boolean isFullyDefined() {
 105         return fullyDefined();
 106     }
 107
 108     @Override
 109     final E createEffective(final StatementFactory<A, D, E> factory) {
 110         return createEffective(factory, this, streamDeclared(), streamEffective());
 111     }
 112
 113     // Creates EffectiveStatement through full materialization and assumes declared statement presence
 114     private @NonNull E createEffective(final StatementFactory<A, D, E> factory,
 115             final StatementContextBase<A, D, E> ctx, final Stream<? extends StmtContext<?, ?, ?>> declared,
 116             final Stream<? extends StmtContext<?, ?, ?>> effective) {
 117         // Statement reference count infrastructure makes an assumption that effective statement is only built after
 118         // the declared statement is already done. Statements tracked by this class always have a declared view, and
 119         // we need to ensure that is built before we touch effective substatements.
 120         //
 121         // Once the effective substatement stream has been exhausted, reference counting will triggers a sweep, hence
 122         // the substatements may be gone by the time the factory attempts to acquire the declared statement.
 123         ctx.declared();
 124
 125         return factory.createEffective(ctx, declared, effective);
 126     }
 127
 128     @Override
 129     final E createInferredEffective(final StatementFactory<A, D, E> factory,
 130             final InferredStatementContext<A, D, E> ctx, final Stream<? extends StmtContext<?, ?, ?>> declared,
 131             final Stream<? extends StmtContext<?, ?, ?>> effective) {
 132         return createEffective(factory, ctx, declared, effective);
 133     }
 134
 135     /**
 136      * Create a new substatement at the specified offset.
 137      *
 138      * @param offset Substatement offset
 139      * @param def definition context
 140      * @param ref source reference
 141      * @param argument statement argument
 142      * @param <X> new substatement argument type
 143      * @param <Y> new substatement declared type
 144      * @param <Z> new substatement effective type
 145      * @return A new substatement
 146      */
 147     @SuppressWarnings("checkstyle:methodTypeParameterName")
 148     final <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>>
 149             AbstractResumedStatement<X, Y, Z> createSubstatement(final int offset,
 150                     final StatementDefinitionContext<X, Y, Z> def, final StatementSourceReference ref,
 151                     final String argument) {
 152         final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase();
 153         checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL,
 154                 "Declared statement cannot be added in effective phase at: %s", sourceReference());
 155
 156         final SubstatementContext<X, Y, Z> ret;
 157         final var implicitParent = definition().getImplicitParentFor(this, def.getPublicView());
 158         if (implicitParent.isPresent()) {
 159             implicitDeclared = true;
 160             final var parent = createUndeclared(offset, implicitParent.orElseThrow(), ref, argument);
 161             ret = new SubstatementContext<>(parent, def, ref, argument);
 162             parent.addEffectiveSubstatement(ret);
 163         } else {
 164             ret = new SubstatementContext<>(this, def, ref, argument);
 165             substatements = substatements.put(offset, ret);
 166         }
 167
 168         def.onStatementAdded(ret);
 169         return ret;
 170     }
 171
 172     private <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>>
 173             UndeclaredStmtCtx<X, Y, Z> createUndeclared(final int offset, final StatementSupport<X, Y, Z> support,
 174                 final StatementSourceReference ref, final String argument) {
 175         final UndeclaredStmtCtx<X, Y, Z> ret;
 176         final var implicitParent = definition().getImplicitParentFor(this, support.getPublicView());
 177         if (implicitParent.isPresent()) {
 178             final var parent = createUndeclared(offset, implicitParent.orElseThrow(), ref, argument);
 179             ret = new ImplicitStmtCtx<>(parent, support, argument);
 180             parent.addEffectiveSubstatement(ret);
 181         } else {
 182             ret = new ImplicitStmtCtx<>(this, support, argument);
 183             substatements = substatements.put(offset, ret);
 184         }
 185         support.onStatementAdded(ret);
 186         return ret;
 187     }
 188
 189     @Override
 190     final Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
 191         return substatements.stream().filter(StmtContext::isSupportedToBuildEffective);
 192     }
 193
 194     @Override
 195     final void dropDeclaredSubstatements() {
 196         substatements = null;
 197     }
 198
 199     /**
 200      * Attempt to lookup a declared substatement by its offset in this statement, passing through any implicit
 201      * statements which have been created to encapsulate it.
 202      *
 203      * @param offset Substatement offset
 204      * @return Substatement, or null if substatement does not exist.
 205      */
 206     final @Nullable AbstractResumedStatement<?, ?, ?> enterSubstatement(final int offset) {
 207         final var stmt = substatements.get(offset);
 208         return stmt == null ? null : unmaskUndeclared(stmt);
 209     }
 210
 211     private static @NonNull AbstractResumedStatement<?, ?, ?> unmaskUndeclared(final ReactorStmtCtx<?, ?, ?> stmt) {
 212         var ret = stmt;
 213         while (!(ret instanceof AbstractResumedStatement)) {
 214             verify(ret instanceof UndeclaredStmtCtx, "Unexpectred statement %s", ret);
 215             ret = ((UndeclaredStmtCtx<?, ?, ?>) ret).getResumedSubstatement();
 216         }
 217         return (AbstractResumedStatement<?, ?, ?>) ret;
 218     }
 219
 220     /**
 221      * End the specified phase for this statement and return this statement's declared parent statement.
 222      *
 223      * @param phase processing phase that ended
 224      * @return Declared parent statement
 225      */
 226     final @Nullable AbstractResumedStatement<?, ?, ?> exitStatement(final ModelProcessingPhase phase) {
 227         finishDeclaration(phase);
 228         final var parent = getParentContext();
 229         if (parent == null) {
 230             return null;
 231         }
 232
 233         var ret = verifyParent(parent);
 234         // Unwind all undeclared statements
 235         while (!(ret instanceof AbstractResumedStatement)) {
 236             ret.finishDeclaration(phase);
 237             ret = verifyParent(ret.getParentContext());
 238         }
 239         return (AbstractResumedStatement<?, ?, ?>) ret;
 240     }
 241
 242     // FIXME: AbstractResumedStatement should only ever have OriginalStmtCtx parents, which would remove the need for
 243     //        this method. In ordered to do that we need to untangle SubstatementContext's users and do not allow it
 244     //        being reparent()ed.
 245     private static OriginalStmtCtx<?, ?, ?> verifyParent(final StatementContextBase<?, ?, ?> parent) {
 246         verify(parent instanceof OriginalStmtCtx, "Unexpected parent context %s", parent);
 247         return (OriginalStmtCtx<?, ?, ?>) parent;
 248     }
 249
 250     final void resizeSubstatements(final int expectedSize) {
 251         substatements = substatements.ensureCapacity(expectedSize);
 252     }
 253
 254     @Override
 255     final void declarationFinished(final ModelProcessingPhase phase) {
 256         finishChildrenDeclaration(phase);
 257         finishDeclaration(phase);
 258     }
 259
 260     private void finishChildrenDeclaration(final ModelProcessingPhase phase) {
 261         checkState(isFullyDefined());
 262         substatements.forEach(stmt -> stmt.declarationFinished(phase));
 263     }
 264 }