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 import static java.util.Objects.requireNonNull;
  14
  15 import com.google.common.collect.ImmutableList;
  16 import java.util.Collection;
  17 import java.util.Iterator;
  18 import java.util.List;
  19 import java.util.Optional;
  20 import java.util.stream.Stream;
  21 import org.eclipse.jdt.annotation.NonNull;
  22 import org.eclipse.jdt.annotation.Nullable;
  23 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  24 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  25 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
  27 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
  28 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
  29 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
  30 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  31 import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement;
  32 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  33 import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 /**
  38  * Intermediate subclass of StatementContextBase facing the parser stream via implementation of ResumedStatement. This
  39  * shields inference-type substatements from these details.
  40  *
  41  * @param <A> Argument type
  42  * @param <D> Declared Statement representation
  43  * @param <E> Effective Statement representation
  44  */
  45 abstract class AbstractResumedStatement<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
  46         extends StatementContextBase<A, D, E> implements ResumedStatement {
  47     private static final Logger LOG = LoggerFactory.getLogger(AbstractResumedStatement.class);
  48
  49     private final @NonNull StatementSourceReference statementDeclSource;
  50     private final String rawArgument;
  51
  52     private List<ReactorStmtCtx<?, ?, ?>> effective = ImmutableList.of();
  53     private StatementMap substatements = StatementMap.empty();
  54     private @Nullable D declaredInstance;
  55
  56     // Copy constructor
  57     AbstractResumedStatement(final AbstractResumedStatement<A, D, E> original) {
  58         super(original);
  59         this.statementDeclSource = original.statementDeclSource;
  60         this.rawArgument = original.rawArgument;
  61         this.substatements = original.substatements;
  62         this.declaredInstance = original.declaredInstance;
  63     }
  64
  65     AbstractResumedStatement(final StatementDefinitionContext<A, D, E> def, final StatementSourceReference ref,
  66             final String rawArgument) {
  67         super(def);
  68         this.statementDeclSource = requireNonNull(ref);
  69         this.rawArgument = def.support().internArgument(rawArgument);
  70     }
  71
  72     AbstractResumedStatement(final StatementDefinitionContext<A, D, E> def, final StatementSourceReference ref,
  73             final String rawArgument, final CopyType copyType) {
  74         super(def, copyType);
  75         this.statementDeclSource = requireNonNull(ref);
  76         this.rawArgument = rawArgument;
  77     }
  78
  79     @Override
  80     public final Optional<StmtContext<A, D, E>> getOriginalCtx() {
  81         return Optional.empty();
  82     }
  83
  84     @Override
  85     public final Optional<StmtContext<A, D, E>> getPreviousCopyCtx() {
  86         return Optional.empty();
  87     }
  88
  89     @Override
  90     public final StatementSourceReference sourceReference() {
  91         return statementDeclSource;
  92     }
  93
  94     @Override
  95     public final String rawArgument() {
  96         return rawArgument;
  97     }
  98
  99     @Override
 100     public Collection<? extends StatementContextBase<?, ?, ?>> mutableDeclaredSubstatements() {
 101         return substatements;
 102     }
 103
 104     @Override
 105     public final Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements() {
 106         return mutableEffectiveSubstatements(effective);
 107     }
 108
 109     @Override
 110     public final void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef) {
 111         effective = removeStatementFromEffectiveSubstatements(effective, statementDef);
 112     }
 113
 114     @Override
 115     public final void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef,
 116             final String statementArg) {
 117         effective = removeStatementFromEffectiveSubstatements(effective, statementDef, statementArg);
 118     }
 119
 120     @Override
 121     public final void addEffectiveSubstatement(final Mutable<?, ?, ?> substatement) {
 122         effective = addEffectiveSubstatement(effective, substatement);
 123     }
 124
 125     @Override
 126     final void addEffectiveSubstatementsImpl(final Collection<? extends Mutable<?, ?, ?>> statements) {
 127         effective = addEffectiveSubstatementsImpl(effective, statements);
 128     }
 129
 130     @Override
 131     public final D declared() {
 132         final D existing;
 133         return (existing = declaredInstance) != null ? existing : loadDeclared();
 134     }
 135
 136     private @NonNull D loadDeclared() {
 137         final ModelProcessingPhase phase = getCompletedPhase();
 138         checkState(phase == ModelProcessingPhase.FULL_DECLARATION || phase == ModelProcessingPhase.EFFECTIVE_MODEL,
 139                 "Cannot build declared instance after phase %s", phase);
 140         return declaredInstance = definition().getFactory().createDeclared(this, substatementsAsDeclared());
 141     }
 142
 143     private @NonNull Stream<DeclaredStatement<?>> substatementsAsDeclared() {
 144         // FIXME: YANGTOOLS-1383: this stream includes implicit case statements, but it should not
 145         return substatements.stream().map(AbstractResumedStatement::declared);
 146     }
 147
 148     @Override
 149     public final StatementDefinition getDefinition() {
 150         return publicDefinition();
 151     }
 152
 153     @Override
 154     public final StatementSourceReference getSourceReference() {
 155         return statementDeclSource;
 156     }
 157
 158     @Override
 159     public final boolean isFullyDefined() {
 160         return fullyDefined();
 161     }
 162
 163     /**
 164      * Create a new substatement at the specified offset.
 165      *
 166      * @param offset Substatement offset
 167      * @param def definition context
 168      * @param ref source reference
 169      * @param argument statement argument
 170      * @param <X> new substatement argument type
 171      * @param <Y> new substatement declared type
 172      * @param <Z> new substatement effective type
 173      * @return A new substatement
 174      */
 175     @SuppressWarnings("checkstyle:methodTypeParameterName")
 176     final <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>>
 177             AbstractResumedStatement<X, Y, Z> createSubstatement(final int offset,
 178                     final StatementDefinitionContext<X, Y, Z> def, final StatementSourceReference ref,
 179                     final String argument) {
 180         final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase();
 181         checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL,
 182                 "Declared statement cannot be added in effective phase at: %s", sourceReference());
 183
 184         final var implicitParent = definition().getImplicitParentFor(this, def.getPublicView());
 185         if (implicitParent.isPresent()) {
 186             return createImplicitParent(offset, implicitParent.orElseThrow(), ref, argument)
 187                 .createSubstatement(0, def, ref, argument);
 188         }
 189
 190         final AbstractResumedStatement<X, Y, Z> ret = new SubstatementContext<>(this, def, ref, argument);
 191         substatements = substatements.put(offset, ret);
 192         def.onStatementAdded(ret);
 193         return ret;
 194     }
 195
 196     @Override
 197     final AbstractResumedStatement<A, D, E> unmodifiedEffectiveSource() {
 198         // This statement is comes from the source
 199         return this;
 200     }
 201
 202     @Override
 203     final boolean hasEmptySubstatements() {
 204         return substatements.size() == 0 && effective.isEmpty();
 205     }
 206
 207     @Override
 208     final boolean noSensitiveSubstatements() {
 209         return hasEmptySubstatements()
 210             || noSensitiveSubstatements(substatements) && noSensitiveSubstatements(effective);
 211     }
 212
 213     @Override
 214     final Iterator<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete() {
 215         return effective.iterator();
 216     }
 217
 218     @Override
 219     final Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
 220         return declaredSubstatements().stream().filter(StmtContext::isSupportedToBuildEffective);
 221     }
 222
 223     @Override
 224     final Stream<? extends @NonNull StmtContext<?, ?, ?>> streamEffective() {
 225         return effective.stream().filter(StmtContext::isSupportedToBuildEffective);
 226     }
 227
 228     @Override
 229     final void markNoParentRef() {
 230         markNoParentRef(substatements);
 231         markNoParentRef(effective);
 232     }
 233
 234     @Override
 235     final int sweepSubstatements() {
 236         // First we need to sweep all statements, which may trigger sweeps all across the place, for example:
 237         // - 'effective' member sweeping a 'substatements' member
 238         // - 'substatements' member sweeping a 'substatements' member which came before it during iteration
 239         // We then iterate once again, counting what remains unswept
 240         sweep(substatements);
 241         sweep(effective);
 242         final int count = countUnswept(substatements) + countUnswept(effective);
 243         if (count != 0) {
 244             LOG.debug("{} children left to sweep from {}", count, this);
 245         }
 246         substatements = null;
 247         effective = null;
 248         return count;
 249     }
 250
 251     /**
 252      * Attempt to lookup a declared substatement by its offset in this statement, passing through any implicit
 253      * statements which have been created to encapsulate it.
 254      *
 255      * @param offset Substatement offset
 256      * @return Substatement, or null if substatement does not exist.
 257      */
 258     final @Nullable AbstractResumedStatement<?, ?, ?> enterSubstatement(final int offset) {
 259         var ret = substatements.get(offset);
 260         if (ret != null) {
 261             while (ret.origin() == StatementOrigin.CONTEXT) {
 262                 ret = verifyNotNull(ret.substatements.get(0));
 263             }
 264         }
 265         return ret;
 266     }
 267
 268     /**
 269      * End the specified phase for this statement and return this statement's declared parent statement.
 270      *
 271      * @param phase processing phase that ended
 272      * @return Declared parent statement
 273      */
 274     final @Nullable AbstractResumedStatement<?, ?, ?> exitStatement(final ModelProcessingPhase phase) {
 275         finishDeclaration(phase);
 276         final var parent = getParentContext();
 277         if (parent == null) {
 278             return null;
 279         }
 280
 281         var ret = verifyParent(parent);
 282         // Unwind all undeclared statements
 283         while (ret.origin() == StatementOrigin.CONTEXT) {
 284             ret.finishDeclaration(phase);
 285             ret = verifyParent(ret.getParentContext());
 286         }
 287         return ret;
 288     }
 289
 290     // FIXME: AbstractResumedStatement should only ever have AbstractResumedStatement parents, which would remove the
 291     //        need for this method. In ordered to do that we need to untangle SubstatementContext's users and do not
 292     //        allow it being reparent()ed.
 293     private static AbstractResumedStatement<?, ?, ?> verifyParent(final StatementContextBase<?, ?, ?> parent) {
 294         verify(parent instanceof AbstractResumedStatement, "Unexpected parent context %s", parent);
 295         return (AbstractResumedStatement<?, ?, ?>) parent;
 296     }
 297
 298     final void resizeSubstatements(final int expectedSize) {
 299         substatements = substatements.ensureCapacity(expectedSize);
 300     }
 301
 302     final void declarationFinished(final ModelProcessingPhase phase) {
 303         finishChildrenDeclaration(phase);
 304         finishDeclaration(phase);
 305     }
 306
 307     private void finishChildrenDeclaration(final ModelProcessingPhase phase) {
 308         checkState(isFullyDefined());
 309         substatements.forEach(stmt -> stmt.declarationFinished(phase));
 310     }
 311
 312     /**
 313      * Ends declared section of current node for the specified phase.
 314      *
 315      * @param phase processing phase that ended
 316      */
 317     private void finishDeclaration(final ModelProcessingPhase phase) {
 318         definition().onDeclarationFinished(this, phase);
 319     }
 320
 321     private AbstractResumedStatement<?, ?, ?> createImplicitParent(final int offset,
 322             final StatementSupport<?, ?, ?> implicitParent, final StatementSourceReference ref, final String argument) {
 323         return createSubstatement(offset, new StatementDefinitionContext<>(implicitParent),
 324             ImplicitSubstatement.of(ref), argument);
 325     }
 326 }