yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ReactorStmtCtx.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.checkArgument;
  11 import static com.google.common.base.Verify.verify;
  12
  13 import com.google.common.base.MoreObjects;
  14 import com.google.common.base.MoreObjects.ToStringHelper;
  15 import com.google.common.base.VerifyException;
  16 import java.util.Collection;
  17 import java.util.Map;
  18 import java.util.Optional;
  19 import java.util.Set;
  20 import org.eclipse.jdt.annotation.NonNull;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.common.QNameModule;
  24 import org.opendaylight.yangtools.yang.common.YangVersion;
  25 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  26 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  27 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  28 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.ConfigEffectiveStatement;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
  33 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  34 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
  35 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  36 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
  37 import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
  38 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
  39 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
  40 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
  41 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry;
  42 import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
  43 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  44 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  45 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
  46 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  47 import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace;
  48 import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51
  52 /**
  53  * Real "core" reactor statement implementation of {@link Mutable}, supporting basic reactor lifecycle.
  54  *
  55  * @param <A> Argument type
  56  * @param <D> Declared Statement representation
  57  * @param <E> Effective Statement representation
  58  */
  59 abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
  60         extends NamespaceStorageSupport implements Mutable<A, D, E>, Current<A, D> {
  61     private static final Logger LOG = LoggerFactory.getLogger(ReactorStmtCtx.class);
  62
  63     /**
  64      * Substatement refcount tracking. This mechanics deals with retaining substatements for the purposes of
  65      * instantiating their lazy copies in InferredStatementContext. It works in concert with {@link #buildEffective()}
  66      * and {@link #declared()}: declared/effective statement views hold an implicit reference and refcount-based
  67      * sweep is not activated until they are done (or this statement is not {@link #isSupportedToBuildEffective}).
  68      *
  69      * <p>
  70      * Reference count is hierarchical in that parent references also pin down their child statements and do not allow
  71      * them to be swept.
  72      *
  73      * <p>
  74      * The counter's positive values are tracking incoming references via {@link #incRef()}/{@link #decRef()} methods.
  75      * Once we transition to sweeping, this value becomes negative counting upwards to {@link #REFCOUNT_NONE} based on
  76      * {@link #sweepOnChildDone()}. Once we reach that, we transition to {@link #REFCOUNT_SWEPT}.
  77      */
  78     private int refcount = REFCOUNT_NONE;
  79     /**
  80      * No outstanding references, this statement is a potential candidate for sweeping, provided it has populated its
  81      * declared and effective views and {@link #parentRef} is known to be absent.
  82      */
  83     private static final int REFCOUNT_NONE = 0;
  84     /**
  85      * Reference count overflow or some other recoverable logic error. Do not rely on refcounts and do not sweep
  86      * anything.
  87      *
  88      * <p>
  89      * Note on value assignment:
  90      * This allow our incRef() to naturally progress to being saturated. Others jump there directly.
  91      * It also makes it  it impossible to observe {@code Interger.MAX_VALUE} children, which we take advantage of for
  92      * {@link #REFCOUNT_SWEEPING}.
  93      */
  94     private static final int REFCOUNT_DEFUNCT = Integer.MAX_VALUE;
  95     /**
  96      * This statement is being actively swept. This is a transient value set when we are sweeping our children, so that
  97      * we prevent re-entering this statement.
  98      *
  99      * <p>
 100      * Note on value assignment:
 101      * The value is lower than any legal child refcount due to {@link #REFCOUNT_DEFUNCT} while still being higher than
 102      * {@link #REFCOUNT_SWEPT}.
 103      */
 104     private static final int REFCOUNT_SWEEPING = -Integer.MAX_VALUE;
 105     /**
 106      * This statement, along with its entire subtree has been swept and we positively know all our children have reached
 107      * this state. We {@link #sweepNamespaces()} upon reaching this state.
 108      *
 109      * <p>
 110      * Note on value assignment:
 111      * This is the lowest value observable, making it easier on checking others on equality.
 112      */
 113     private static final int REFCOUNT_SWEPT = Integer.MIN_VALUE;
 114
 115     private @Nullable E effectiveInstance;
 116
 117     // Master flag controlling whether this context can yield an effective statement
 118     // FIXME: investigate the mechanics that are being supported by this, as it would be beneficial if we can get rid
 119     //        of this flag -- eliminating the initial alignment shadow used by below gap-filler fields.
 120     private boolean isSupportedToBuildEffective = true;
 121
 122     // EffectiveConfig mapping
 123     private static final int MASK_CONFIG                = 0x03;
 124     private static final int HAVE_CONFIG                = 0x04;
 125     // Effective instantiation mechanics for StatementContextBase: if this flag is set all substatements are known not
 126     // change when instantiated. This includes context-independent statements as well as any statements which are
 127     // ignored during copy instantiation.
 128     private static final int ALL_INDEPENDENT            = 0x08;
 129     // Flag bit assignments
 130     private static final int IS_SUPPORTED_BY_FEATURES   = 0x10;
 131     private static final int HAVE_SUPPORTED_BY_FEATURES = 0x20;
 132     private static final int IS_IGNORE_IF_FEATURE       = 0x40;
 133     private static final int HAVE_IGNORE_IF_FEATURE     = 0x80;
 134     // Have-and-set flag constants, also used as masks
 135     private static final int SET_SUPPORTED_BY_FEATURES  = HAVE_SUPPORTED_BY_FEATURES | IS_SUPPORTED_BY_FEATURES;
 136     private static final int SET_IGNORE_IF_FEATURE      = HAVE_IGNORE_IF_FEATURE | IS_IGNORE_IF_FEATURE;
 137
 138     private static final EffectiveConfig[] EFFECTIVE_CONFIGS;
 139
 140     static {
 141         final EffectiveConfig[] values = EffectiveConfig.values();
 142         final int length = values.length;
 143         verify(length == 4, "Unexpected EffectiveConfig cardinality %s", length);
 144         EFFECTIVE_CONFIGS = values;
 145     }
 146
 147     // Flags for use with SubstatementContext. These are hiding in the alignment shadow created by above boolean and
 148     // hence improve memory layout.
 149     private byte flags;
 150
 151     // Flag for use with AbstractResumedStatement and ReplicateStatementContext. This is hiding in the alignment shadow
 152     // created by above boolean
 153     // FIXME: move this out once we have JDK15+
 154     private boolean fullyDefined;
 155
 156     // SchemaPath cache for use with SubstatementContext and InferredStatementContext. This hurts RootStatementContext
 157     // a bit in terms of size -- but those are only a few and SchemaPath is on its way out anyway.
 158     // FIXME: this should become 'QName'
 159     private SchemaPath schemaPath;
 160
 161     ReactorStmtCtx() {
 162         // Empty on purpose
 163     }
 164
 165     ReactorStmtCtx(final ReactorStmtCtx<A, D, E> original) {
 166         isSupportedToBuildEffective = original.isSupportedToBuildEffective;
 167         fullyDefined = original.fullyDefined;
 168         flags = original.flags;
 169     }
 170
 171     // Used by ReplicaStatementContext only
 172     ReactorStmtCtx(final ReactorStmtCtx<A, D, E> original, final Void dummy) {
 173         fullyDefined = isSupportedToBuildEffective = original.isSupportedToBuildEffective;
 174         flags = original.flags;
 175     }
 176
 177     //
 178     //
 179     // Common public interface contracts with simple mechanics. Please keep this in one logical block, so we do not end
 180     // up mixing concerns and simple details with more complex logic.
 181     //
 182     //
 183
 184     @Override
 185     public abstract StatementContextBase<?, ?, ?> getParentContext();
 186
 187     @Override
 188     public abstract RootStatementContext<?, ?, ?> getRoot();
 189
 190     @Override
 191     public abstract Collection<? extends StatementContextBase<?, ?, ?>> mutableDeclaredSubstatements();
 192
 193     @Override
 194     public final @NonNull Registry getBehaviourRegistry() {
 195         return getRoot().getBehaviourRegistryImpl();
 196     }
 197
 198     @Override
 199     public final YangVersion yangVersion() {
 200         return getRoot().getRootVersionImpl();
 201     }
 202
 203     @Override
 204     public final void setRootVersion(final YangVersion version) {
 205         getRoot().setRootVersionImpl(version);
 206     }
 207
 208     @Override
 209     public final void addRequiredSource(final SourceIdentifier dependency) {
 210         getRoot().addRequiredSourceImpl(dependency);
 211     }
 212
 213     @Override
 214     public final void setRootIdentifier(final SourceIdentifier identifier) {
 215         getRoot().setRootIdentifierImpl(identifier);
 216     }
 217
 218     @Override
 219     public final boolean isEnabledSemanticVersioning() {
 220         return getRoot().isEnabledSemanticVersioningImpl();
 221     }
 222
 223     @Override
 224     public final ModelActionBuilder newInferenceAction(final ModelProcessingPhase phase) {
 225         return getRoot().getSourceContext().newInferenceAction(phase);
 226     }
 227
 228     @Override
 229     public final StatementDefinition publicDefinition() {
 230         return definition().getPublicView();
 231     }
 232
 233     @Override
 234     public final Parent effectiveParent() {
 235         return getParentContext();
 236     }
 237
 238     @Override
 239     public final QName moduleName() {
 240         final RootStatementContext<?, ?, ?> root = getRoot();
 241         return QName.create(StmtContextUtils.getRootModuleQName(root), root.getRawArgument());
 242     }
 243
 244     @Override
 245     public final EffectiveStatement<?, ?> original() {
 246         return getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
 247     }
 248
 249     //
 250     // In the next two methods we are looking for an effective statement. If we already have an effective instance,
 251     // defer to it's implementation of the equivalent search. Otherwise we search our substatement contexts.
 252     //
 253     // Note that the search function is split, so as to allow InferredStatementContext to do its own thing first.
 254     //
 255
 256     @Override
 257     public final <X, Z extends EffectiveStatement<X, ?>> @NonNull Optional<X> findSubstatementArgument(
 258             final @NonNull Class<Z> type) {
 259         final E local = effectiveInstance;
 260         return local != null ? local.findFirstEffectiveSubstatementArgument(type)
 261             : findSubstatementArgumentImpl(type);
 262     }
 263
 264     @Override
 265     public final boolean hasSubstatement(final @NonNull Class<? extends EffectiveStatement<?, ?>> type) {
 266         final E local = effectiveInstance;
 267         return local != null ? local.findFirstEffectiveSubstatement(type).isPresent()
 268             : hasSubstatementImpl(type);
 269     }
 270
 271     // Visible due to InferredStatementContext's override. At this point we do not have an effective instance available.
 272     <X, Z extends EffectiveStatement<X, ?>> @NonNull Optional<X> findSubstatementArgumentImpl(
 273             final @NonNull Class<Z> type) {
 274         return allSubstatementsStream()
 275             .filter(ctx -> ctx.isSupportedToBuildEffective() && ctx.producesEffective(type))
 276             .findAny()
 277             .map(ctx -> (X) ctx.getArgument());
 278     }
 279
 280     // Visible due to InferredStatementContext's override. At this point we do not have an effective instance available.
 281     boolean hasSubstatementImpl(final @NonNull Class<? extends EffectiveStatement<?, ?>> type) {
 282         return allSubstatementsStream()
 283             .anyMatch(ctx -> ctx.isSupportedToBuildEffective() && ctx.producesEffective(type));
 284     }
 285
 286     @Override
 287     @Deprecated
 288     @SuppressWarnings("unchecked")
 289     public final <Z extends EffectiveStatement<A, D>> StmtContext<A, D, Z> caerbannog() {
 290         return (StmtContext<A, D, Z>) this;
 291     }
 292
 293     @Override
 294     public final String toString() {
 295         return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString();
 296     }
 297
 298     protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 299         return toStringHelper.add("definition", definition()).add("rawArgument", rawArgument());
 300     }
 301
 302     /**
 303      * Return the context in which this statement was defined.
 304      *
 305      * @return statement definition
 306      */
 307     abstract @NonNull StatementDefinitionContext<A, D, E> definition();
 308
 309     //
 310     //
 311     // NamespaceStorageSupport/Mutable integration methods. Keep these together.
 312     //
 313     //
 314
 315     @Override
 316     public final <K, V, T extends K, N extends ParserNamespace<K, V>> V namespaceItem(final Class<@NonNull N> type,
 317             final T key) {
 318         return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this, key);
 319     }
 320
 321     @Override
 322     public final <K, V, N extends ParserNamespace<K, V>> Map<K, V> namespace(final Class<@NonNull N> type) {
 323         return getNamespace(type);
 324     }
 325
 326     @Override
 327     public final <K, V, N extends ParserNamespace<K, V>>
 328             Map<K, V> localNamespacePortion(final Class<@NonNull N> type) {
 329         return getLocalNamespace(type);
 330     }
 331
 332     @Override
 333     protected final void checkLocalNamespaceAllowed(final Class<? extends ParserNamespace<?, ?>> type) {
 334         definition().checkNamespaceAllowed(type);
 335     }
 336
 337     @Override
 338     protected <K, V, N extends ParserNamespace<K, V>> void onNamespaceElementAdded(final Class<N> type, final K key,
 339             final V value) {
 340         // definition().onNamespaceElementAdded(this, type, key, value);
 341     }
 342
 343     /**
 344      * Return the effective statement view of a copy operation. This method may return one of:
 345      * <ul>
 346      *   <li>{@code this}, when the effective view did not change</li>
 347      *   <li>an InferredStatementContext, when there is a need for inference-equivalent copy</li>
 348      *   <li>{@code null}, when the statement failed to materialize</li>
 349      * </ul>
 350      *
 351      * @param parent Proposed new parent
 352      * @param type Copy operation type
 353      * @param targetModule New target module
 354      * @return {@link ReactorStmtCtx} holding effective view
 355      */
 356     abstract @Nullable ReactorStmtCtx<?, ?, ?> asEffectiveChildOf(StatementContextBase<?, ?, ?> parent, CopyType type,
 357         QNameModule targetModule);
 358
 359     @Override
 360     public final ReactorStmtCtx<A, D, E> replicaAsChildOf(final Mutable<?, ?, ?> parent) {
 361         checkArgument(parent instanceof StatementContextBase, "Unsupported parent %s", parent);
 362         return replicaAsChildOf((StatementContextBase<?, ?, ?>) parent);
 363     }
 364
 365     abstract @NonNull ReplicaStatementContext<A, D, E> replicaAsChildOf(@NonNull StatementContextBase<?, ?, ?> parent);
 366
 367     //
 368     //
 369     // Statement build entry points -- both public and package-private.
 370     //
 371     //
 372
 373     @Override
 374     public final E buildEffective() {
 375         final E existing;
 376         return (existing = effectiveInstance) != null ? existing : loadEffective();
 377     }
 378
 379     private @NonNull E loadEffective() {
 380         // Creating an effective statement does not strictly require a declared instance -- there are statements like
 381         // 'input', which are implicitly defined.
 382         // Our implementation design makes an invariant assumption that buildDeclared() has been called by the time
 383         // we attempt to create effective statement:
 384         declared();
 385
 386         final E ret = effectiveInstance = createEffective();
 387         // we have called createEffective(), substatements are no longer guarded by us. Let's see if we can clear up
 388         // some residue.
 389         if (refcount == REFCOUNT_NONE) {
 390             sweepOnDecrement();
 391         }
 392         return ret;
 393     }
 394
 395     abstract @NonNull E createEffective();
 396
 397     /**
 398      * Try to execute current {@link ModelProcessingPhase} of source parsing. If the phase has already been executed,
 399      * this method does nothing.
 400      *
 401      * @param phase to be executed (completed)
 402      * @return true if phase was successfully completed
 403      * @throws SourceException when an error occurred in source parsing
 404      */
 405     final boolean tryToCompletePhase(final ModelProcessingPhase phase) {
 406         return phase.isCompletedBy(getCompletedPhase()) || doTryToCompletePhase(phase);
 407     }
 408
 409     abstract boolean doTryToCompletePhase(ModelProcessingPhase phase);
 410
 411     //
 412     //
 413     // Flags-based mechanics. These include public interfaces as well as all the crud we have lurking in our alignment
 414     // shadow.
 415     //
 416     //
 417
 418     @Override
 419     public final boolean isSupportedToBuildEffective() {
 420         return isSupportedToBuildEffective;
 421     }
 422
 423     @Override
 424     public final void setIsSupportedToBuildEffective(final boolean isSupportedToBuildEffective) {
 425         this.isSupportedToBuildEffective = isSupportedToBuildEffective;
 426     }
 427
 428     @Override
 429     public final boolean isSupportedByFeatures() {
 430         final int fl = flags & SET_SUPPORTED_BY_FEATURES;
 431         if (fl != 0) {
 432             return fl == SET_SUPPORTED_BY_FEATURES;
 433         }
 434         if (isIgnoringIfFeatures()) {
 435             flags |= SET_SUPPORTED_BY_FEATURES;
 436             return true;
 437         }
 438
 439         /*
 440          * If parent is supported, we need to check if-features statements of this context.
 441          */
 442         if (isParentSupportedByFeatures()) {
 443             // If the set of supported features has not been provided, all features are supported by default.
 444             final Set<QName> supportedFeatures = getFromNamespace(SupportedFeaturesNamespace.class,
 445                     SupportedFeatures.SUPPORTED_FEATURES);
 446             if (supportedFeatures == null || StmtContextUtils.checkFeatureSupport(this, supportedFeatures)) {
 447                 flags |= SET_SUPPORTED_BY_FEATURES;
 448                 return true;
 449             }
 450         }
 451
 452         // Either parent is not supported or this statement is not supported
 453         flags |= HAVE_SUPPORTED_BY_FEATURES;
 454         return false;
 455     }
 456
 457     protected abstract boolean isParentSupportedByFeatures();
 458
 459     /**
 460      * Config statements are not all that common which means we are performing a recursive search towards the root
 461      * every time {@link #effectiveConfig()} is invoked. This is quite expensive because it causes a linear search
 462      * for the (usually non-existent) config statement.
 463      *
 464      * <p>
 465      * This method maintains a resolution cache, so once we have returned a result, we will keep on returning the same
 466      * result without performing any lookups, solely to support {@link #effectiveConfig()}.
 467      *
 468      * <p>
 469      * Note: use of this method implies that {@link #isIgnoringConfig()} is realized with
 470      *       {@link #isIgnoringConfig(StatementContextBase)}.
 471      */
 472     final @NonNull EffectiveConfig effectiveConfig(final ReactorStmtCtx<?, ?, ?> parent) {
 473         return (flags & HAVE_CONFIG) != 0 ? EFFECTIVE_CONFIGS[flags & MASK_CONFIG] : loadEffectiveConfig(parent);
 474     }
 475
 476     private @NonNull EffectiveConfig loadEffectiveConfig(final ReactorStmtCtx<?, ?, ?> parent) {
 477         final EffectiveConfig parentConfig = parent.effectiveConfig();
 478
 479         final EffectiveConfig myConfig;
 480         if (parentConfig != EffectiveConfig.IGNORED && !definition().support().isIgnoringConfig()) {
 481             final Optional<Boolean> optConfig = findSubstatementArgument(ConfigEffectiveStatement.class);
 482             if (optConfig.isPresent()) {
 483                 if (optConfig.orElseThrow()) {
 484                     // Validity check: if parent is config=false this cannot be a config=true
 485                     InferenceException.throwIf(parentConfig == EffectiveConfig.FALSE, this,
 486                         "Parent node has config=false, this node must not be specifed as config=true");
 487                     myConfig = EffectiveConfig.TRUE;
 488                 } else {
 489                     myConfig = EffectiveConfig.FALSE;
 490                 }
 491             } else {
 492                 // If "config" statement is not specified, the default is the same as the parent's "config" value.
 493                 myConfig = parentConfig;
 494             }
 495         } else {
 496             myConfig = EffectiveConfig.IGNORED;
 497         }
 498
 499         flags = (byte) (flags & ~MASK_CONFIG | HAVE_CONFIG | myConfig.ordinal());
 500         return myConfig;
 501     }
 502
 503     protected abstract boolean isIgnoringConfig();
 504
 505     /**
 506      * This method maintains a resolution cache for ignore config, so once we have returned a result, we will
 507      * keep on returning the same result without performing any lookups. Exists only to support
 508      * {@link SubstatementContext#isIgnoringConfig()}.
 509      *
 510      * <p>
 511      * Note: use of this method implies that {@link #isConfiguration()} is realized with
 512      *       {@link #effectiveConfig(StatementContextBase)}.
 513      */
 514     final boolean isIgnoringConfig(final StatementContextBase<?, ?, ?> parent) {
 515         return EffectiveConfig.IGNORED == effectiveConfig(parent);
 516     }
 517
 518     protected abstract boolean isIgnoringIfFeatures();
 519
 520     /**
 521      * This method maintains a resolution cache for ignore if-feature, so once we have returned a result, we will
 522      * keep on returning the same result without performing any lookups. Exists only to support
 523      * {@link SubstatementContext#isIgnoringIfFeatures()}.
 524      */
 525     final boolean isIgnoringIfFeatures(final StatementContextBase<?, ?, ?> parent) {
 526         final int fl = flags & SET_IGNORE_IF_FEATURE;
 527         if (fl != 0) {
 528             return fl == SET_IGNORE_IF_FEATURE;
 529         }
 530         if (definition().support().isIgnoringIfFeatures() || parent.isIgnoringIfFeatures()) {
 531             flags |= SET_IGNORE_IF_FEATURE;
 532             return true;
 533         }
 534
 535         flags |= HAVE_IGNORE_IF_FEATURE;
 536         return false;
 537     }
 538
 539     // These two exist only due to memory optimization, should live in AbstractResumedStatement.
 540     final boolean fullyDefined() {
 541         return fullyDefined;
 542     }
 543
 544     final void setFullyDefined() {
 545         fullyDefined = true;
 546     }
 547
 548     // This exists only due to memory optimization, should live in ReplicaStatementContext.
 549     final boolean haveSourceReference() {
 550         return fullyDefined;
 551     }
 552
 553     // These two exist only for StatementContextBase. Since we are squeezed for size, with only a single bit available
 554     // in flags, we default to 'false' and only set the flag to true when we are absolutely sure -- and all other cases
 555     // err on the side of caution by taking the time to evaluate each substatement separately.
 556     final boolean allSubstatementsContextIndependent() {
 557         return (flags & ALL_INDEPENDENT) != 0;
 558     }
 559
 560     final void setAllSubstatementsContextIndependent() {
 561         flags |= ALL_INDEPENDENT;
 562     }
 563
 564     //
 565     //
 566     // Various functionality from AbstractTypeStatementSupport. This used to work on top of SchemaPath, now it still
 567     // lives here. Ultimate future is either proper graduation or (more likely) move to AbstractTypeStatementSupport.
 568     //
 569     //
 570
 571     @Override
 572     public final QName argumentAsTypeQName() {
 573         final Object argument = argument();
 574         verify(argument instanceof String, "Unexpected argument %s", argument);
 575         return interpretAsQName((String) argument);
 576     }
 577
 578     @Override
 579     public final QNameModule effectiveNamespace() {
 580         // FIXME: there has to be a better way to do this
 581         return getSchemaPath().getLastComponent().getModule();
 582     }
 583
 584     //
 585     //
 586     // Common SchemaPath cache. All of this is bound to be removed once YANGTOOLS-1066 is done.
 587     //
 588     //
 589
 590     // Exists only to support {SubstatementContext,InferredStatementContext}.schemaPath()
 591     @Deprecated
 592     final @Nullable SchemaPath substatementGetSchemaPath() {
 593         if (schemaPath == null) {
 594             schemaPath = createSchemaPath((StatementContextBase<?, ?, ?>) coerceParentContext());
 595         }
 596         return schemaPath;
 597     }
 598
 599     // FIXME: 7.0.0: this method's logic needs to be moved to the respective StatementSupport classes
 600     @Deprecated
 601     private SchemaPath createSchemaPath(final StatementContextBase<?, ?, ?> parent) {
 602         final SchemaPath parentPath = parent.getSchemaPath();
 603         if (StmtContextUtils.isUnknownStatement(this)) {
 604             return parentPath.createChild(publicDefinition().getStatementName());
 605         }
 606         final Object argument = argument();
 607         if (argument instanceof QName) {
 608             final QName qname = (QName) argument;
 609             if (producesDeclared(UsesStatement.class)) {
 610                 return parentPath;
 611             }
 612
 613             return parentPath.createChild(qname);
 614         }
 615         if (argument instanceof String) {
 616             return parentPath.createChild(interpretAsQName((String) argument));
 617         }
 618         if (argument instanceof SchemaNodeIdentifier
 619                 && (producesDeclared(AugmentStatement.class) || producesDeclared(RefineStatement.class)
 620                         || producesDeclared(DeviationStatement.class))) {
 621
 622             return parentPath.createChild(((SchemaNodeIdentifier) argument).getNodeIdentifiers());
 623         }
 624
 625         // FIXME: this does not look right, investigate more?
 626         return parentPath;
 627     }
 628
 629     private @NonNull QName interpretAsQName(final String argument) {
 630         // FIXME: This may yield illegal argument exceptions
 631         return StmtContextUtils.qnameFromArgument(getOriginalCtx().orElse(this), argument);
 632     }
 633
 634     //
 635     //
 636     // Reference counting mechanics start. Please keep these methods in one block for clarity. Note this does not
 637     // contribute to state visible outside of this package.
 638     //
 639     //
 640
 641     /**
 642      * Local knowledge of {@link #refcount} values up to statement root. We use this field to prevent recursive lookups
 643      * in {@link #noParentRefs(StatementContextBase)} -- once we discover a parent reference once, we keep that
 644      * knowledge and update it when {@link #sweep()} is invoked.
 645      */
 646     private byte parentRef = PARENTREF_UNKNOWN;
 647     private static final byte PARENTREF_UNKNOWN = -1;
 648     private static final byte PARENTREF_ABSENT  = 0;
 649     private static final byte PARENTREF_PRESENT = 1;
 650
 651     /**
 652      * Acquire a reference on this context. As long as there is at least one reference outstanding,
 653      * {@link #buildEffective()} will not result in {@link #effectiveSubstatements()} being discarded.
 654      *
 655      * @throws VerifyException if {@link #effectiveSubstatements()} has already been discarded
 656      */
 657     final void incRef() {
 658         final int current = refcount;
 659         verify(current >= REFCOUNT_NONE, "Attempted to access reference count of %s", this);
 660         if (current != REFCOUNT_DEFUNCT) {
 661             // Note: can end up becoming REFCOUNT_DEFUNCT on overflow
 662             refcount = current + 1;
 663         } else {
 664             LOG.debug("Disabled refcount increment of {}", this);
 665         }
 666     }
 667
 668     /**
 669      * Release a reference on this context. This call may result in {@link #effectiveSubstatements()} becoming
 670      * unavailable.
 671      */
 672     final void decRef() {
 673         final int current = refcount;
 674         if (current == REFCOUNT_DEFUNCT) {
 675             // no-op
 676             LOG.debug("Disabled refcount decrement of {}", this);
 677             return;
 678         }
 679         if (current <= REFCOUNT_NONE) {
 680             // Underflow, become defunct
 681             // FIXME: add a global 'warn once' flag
 682             LOG.warn("Statement refcount underflow, reference counting disabled for {}", this, new Throwable());
 683             refcount = REFCOUNT_DEFUNCT;
 684             return;
 685         }
 686
 687         refcount = current - 1;
 688         LOG.trace("Refcount {} on {}", refcount, this);
 689
 690         if (refcount == REFCOUNT_NONE) {
 691             lastDecRef();
 692         }
 693     }
 694
 695     /**
 696      * Return {@code true} if this context has an outstanding reference.
 697      *
 698      * @return True if this context has an outstanding reference.
 699      */
 700     final boolean haveRef() {
 701         return refcount > REFCOUNT_NONE;
 702     }
 703
 704     private void lastDecRef() {
 705         if (noImplictRef()) {
 706             // We are no longer guarded by effective instance
 707             sweepOnDecrement();
 708             return;
 709         }
 710
 711         final byte prevRefs = parentRef;
 712         if (prevRefs == PARENTREF_ABSENT) {
 713             // We are the last reference towards root, any children who observed PARENTREF_PRESENT from us need to be
 714             // updated
 715             markNoParentRef();
 716         } else if (prevRefs == PARENTREF_UNKNOWN) {
 717             // Noone observed our parentRef, just update it
 718             loadParentRefcount();
 719         }
 720     }
 721
 722     static final void markNoParentRef(final Collection<? extends ReactorStmtCtx<?, ?, ?>> substatements) {
 723         for (ReactorStmtCtx<?, ?, ?> stmt : substatements) {
 724             final byte prevRef = stmt.parentRef;
 725             stmt.parentRef = PARENTREF_ABSENT;
 726             if (prevRef == PARENTREF_PRESENT && stmt.refcount == REFCOUNT_NONE) {
 727                 // Child thinks it is pinned down, update its perspective
 728                 stmt.markNoParentRef();
 729             }
 730         }
 731     }
 732
 733     abstract void markNoParentRef();
 734
 735     static final void sweep(final Collection<? extends ReactorStmtCtx<?, ?, ?>> substatements) {
 736         for (ReactorStmtCtx<?, ?, ?> stmt : substatements) {
 737             stmt.sweep();
 738         }
 739     }
 740
 741     /**
 742      * Sweep this statement context as a result of {@link #sweepSubstatements()}, i.e. when parent is also being swept.
 743      */
 744     private void sweep() {
 745         parentRef = PARENTREF_ABSENT;
 746         if (refcount == REFCOUNT_NONE && noImplictRef()) {
 747             LOG.trace("Releasing {}", this);
 748             sweepState();
 749         }
 750     }
 751
 752     static final int countUnswept(final Collection<? extends ReactorStmtCtx<?, ?, ?>> substatements) {
 753         int result = 0;
 754         for (ReactorStmtCtx<?, ?, ?> stmt : substatements) {
 755             if (stmt.refcount > REFCOUNT_NONE || !stmt.noImplictRef()) {
 756                 result++;
 757             }
 758         }
 759         return result;
 760     }
 761
 762     /**
 763      * Implementation-specific sweep action. This is expected to perform a recursive {@link #sweep(Collection)} on all
 764      * {@link #declaredSubstatements()} and {@link #effectiveSubstatements()} and report the result of the sweep
 765      * operation.
 766      *
 767      * <p>
 768      * {@link #effectiveSubstatements()} as well as namespaces may become inoperable as a result of this operation.
 769      *
 770      * @return True if the entire tree has been completely swept, false otherwise.
 771      */
 772     abstract int sweepSubstatements();
 773
 774     // Called when this statement does not have an implicit reference and have reached REFCOUNT_NONE
 775     private void sweepOnDecrement() {
 776         LOG.trace("Sweeping on decrement {}", this);
 777         if (noParentRef()) {
 778             // No further parent references, sweep our state.
 779             sweepState();
 780         }
 781
 782         // Propagate towards parent if there is one
 783         final ReactorStmtCtx<?, ?, ?> parent = getParentContext();
 784         if (parent != null) {
 785             parent.sweepOnChildDecrement();
 786         }
 787     }
 788
 789     // Called from child when it has lost its final reference
 790     private void sweepOnChildDecrement() {
 791         if (isAwaitingChildren()) {
 792             // We are a child for which our parent is waiting. Notify it and we are done.
 793             sweepOnChildDone();
 794             return;
 795         }
 796
 797         // Check parent reference count
 798         final int refs = refcount;
 799         if (refs > REFCOUNT_NONE || refs <= REFCOUNT_SWEEPING || !noImplictRef()) {
 800             // No-op
 801             return;
 802         }
 803
 804         // parent is potentially reclaimable
 805         if (noParentRef()) {
 806             LOG.trace("Cleanup {} of parent {}", refcount, this);
 807             if (sweepState()) {
 808                 final ReactorStmtCtx<?, ?, ?> parent = getParentContext();
 809                 if (parent != null) {
 810                     parent.sweepOnChildDecrement();
 811                 }
 812             }
 813         }
 814     }
 815
 816     private boolean noImplictRef() {
 817         return effectiveInstance != null || !isSupportedToBuildEffective();
 818     }
 819
 820     private boolean noParentRef() {
 821         return parentRefcount() == PARENTREF_ABSENT;
 822     }
 823
 824     private byte parentRefcount() {
 825         final byte refs;
 826         return (refs = parentRef) != PARENTREF_UNKNOWN ? refs : loadParentRefcount();
 827     }
 828
 829     private byte loadParentRefcount() {
 830         return parentRef = calculateParentRefcount();
 831     }
 832
 833     private byte calculateParentRefcount() {
 834         final ReactorStmtCtx<?, ?, ?> parent = getParentContext();
 835         if (parent == null) {
 836             return PARENTREF_ABSENT;
 837         }
 838         // There are three possibilities:
 839         // - REFCOUNT_NONE, in which case we need to search next parent
 840         // - negative (< REFCOUNT_NONE), meaning parent is in some stage of sweeping, hence it does not have
 841         //   a reference to us
 842         // - positive (> REFCOUNT_NONE), meaning parent has an explicit refcount which is holding us down
 843         final int refs = parent.refcount;
 844         if (refs == REFCOUNT_NONE) {
 845             return parent.parentRefcount();
 846         }
 847         return refs < REFCOUNT_NONE ? PARENTREF_ABSENT : PARENTREF_PRESENT;
 848     }
 849
 850     private boolean isAwaitingChildren() {
 851         return refcount > REFCOUNT_SWEEPING && refcount < REFCOUNT_NONE;
 852     }
 853
 854     private void sweepOnChildDone() {
 855         LOG.trace("Sweeping on child done {}", this);
 856         final int current = refcount;
 857         if (current >= REFCOUNT_NONE) {
 858             // no-op, perhaps we want to handle some cases differently?
 859             LOG.trace("Ignoring child sweep of {} for {}", this, current);
 860             return;
 861         }
 862         verify(current != REFCOUNT_SWEPT, "Attempt to sweep a child of swept %s", this);
 863
 864         refcount = current + 1;
 865         LOG.trace("Child refcount {}", refcount);
 866         if (refcount == REFCOUNT_NONE) {
 867             sweepDone();
 868             final ReactorStmtCtx<?, ?, ?> parent = getParentContext();
 869             LOG.trace("Propagating to parent {}", parent);
 870             if (parent != null && parent.isAwaitingChildren()) {
 871                 parent.sweepOnChildDone();
 872             }
 873         }
 874     }
 875
 876     private void sweepDone() {
 877         LOG.trace("Sweep done for {}", this);
 878         refcount = REFCOUNT_SWEPT;
 879         sweepNamespaces();
 880     }
 881
 882     private boolean sweepState() {
 883         refcount = REFCOUNT_SWEEPING;
 884         final int childRefs = sweepSubstatements();
 885         if (childRefs == 0) {
 886             sweepDone();
 887             return true;
 888         }
 889         if (childRefs < 0 || childRefs >= REFCOUNT_DEFUNCT) {
 890             // FIXME: add a global 'warn once' flag
 891             LOG.warn("Negative child refcount {} cannot be stored, reference counting disabled for {}", childRefs, this,
 892                 new Throwable());
 893             refcount = REFCOUNT_DEFUNCT;
 894         } else {
 895             LOG.trace("Still {} outstanding children of {}", childRefs, this);
 896             refcount = -childRefs;
 897         }
 898         return false;
 899     }
 900 }