import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CommonStmtCtx;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures;
import org.slf4j.Logger;
* @param <E> Effective Statement representation
*/
abstract class ReactorStmtCtx<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
- extends NamespaceStorageSupport implements Mutable<A, D, E> {
+ extends NamespaceStorageSupport implements Mutable<A, D, E>, Current<A, D> {
private static final Logger LOG = LoggerFactory.getLogger(ReactorStmtCtx.class);
/**
* Substatement refcount tracking. This mechanics deals with retaining substatements for the purposes of
* instantiating their lazy copies in InferredStatementContext. It works in concert with {@link #buildEffective()}
- * and {@link #buildDeclared()}: declared/effective statement views hold an implicit reference and refcount-based
+ * and {@link #declared()}: declared/effective statement views hold an implicit reference and refcount-based
* sweep is not activated until they are done (or this statement is not {@link #isSupportedToBuildEffective}).
*
* <p>
}
@Override
- public final YangVersion getRootVersion() {
+ public final YangVersion yangVersion() {
return getRoot().getRootVersionImpl();
}
return definition().getPublicView();
}
+ @Override
+ public final Parent effectiveParent() {
+ return getParentContext();
+ }
+
+ @Override
+ public final CommonStmtCtx root() {
+ return getRoot();
+ }
+
+ @Override
+ public final EffectiveStatement<?, ?> original() {
+ return getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
+ }
+
+ @Override
+ @Deprecated
+ @SuppressWarnings("unchecked")
+ public final <Z extends EffectiveStatement<A, D>> StmtContext<A, D, Z> caerbannog() {
+ return (StmtContext<A, D, Z>) this;
+ }
+
@Override
public final String toString() {
return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString();
//
@Override
- public final <K, V, T extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(
- final Class<@NonNull N> type, final T key) {
+ public final <K, V, T extends K, N extends IdentifierNamespace<K, V>> V namespaceItem(final Class<@NonNull N> type,
+ final T key) {
return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this, key);
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(final Class<N> type) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> namespace(final Class<@NonNull N> type) {
return getNamespace(type);
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(
- final Class<N> type) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> localNamespace(final Class<@NonNull N> type) {
return getLocalNamespace(type);
}
// 'input', which are implicitly defined.
// Our implementation design makes an invariant assumption that buildDeclared() has been called by the time
// we attempt to create effective statement:
- buildDeclared();
+ declared();
final E ret = effectiveInstance = createEffective();
// we have called createEffective(), substatements are no longer guarded by us. Let's see if we can clear up
abstract @NonNull E createEffective();
+ /**
+ * Try to execute current {@link ModelProcessingPhase} of source parsing. If the phase has already been executed,
+ * this method does nothing.
+ *
+ * @param phase to be executed (completed)
+ * @return true if phase was successfully completed
+ * @throws SourceException when an error occurred in source parsing
+ */
+ final boolean tryToCompletePhase(final ModelProcessingPhase phase) {
+ return phase.isCompletedBy(getCompletedPhase()) || doTryToCompletePhase(phase);
+ }
+
+ abstract boolean doTryToCompletePhase(ModelProcessingPhase phase);
+
//
//
// Flags-based mechanics. These include public interfaces as well as all the crud we have lurking in our alignment
isConfig = optConfig.orElseThrow();
if (isConfig) {
// Validity check: if parent is config=false this cannot be a config=true
- InferenceException.throwIf(!parent.isConfiguration(), sourceReference(),
- "Parent node has config=false, this node must not be specifed as config=true");
+ InferenceException.throwIf(!parent.effectiveConfig(), this,
+ "Parent node has config=false, this node must not be specifed as config=true");
}
} else {
// If "config" statement is not specified, the default is the same as the parent's "config" value.
- isConfig = parent.isConfiguration();
+ isConfig = parent.effectiveConfig();
}
// Resolved, make sure we cache this return
return false;
}
- // These two exists only due to memory optimization, should live in AbstractResumedStatement
+ // These two exists only due to memory optimization, should live in AbstractResumedStatement. We are also reusing
+ // this for ReplicaStatementContext's refcount tracking.
final boolean fullyDefined() {
return fullyDefined;
}
//
//
- abstract @NonNull Optional<SchemaPath> schemaPath();
-
// Exists only to support {SubstatementContext,InferredStatementContext}.schemaPath()
@Deprecated
final @NonNull Optional<SchemaPath> substatementGetSchemaPath() {
//
//
+ /**
+ * Local knowledge of {@link #refcount} values up to statement root. We use this field to prevent recursive lookups
+ * in {@link #noParentRefs(StatementContextBase)} -- once we discover a parent reference once, we keep that
+ * knowledge and update it when {@link #sweep()} is invoked.
+ */
+ private byte parentRef = PARENTREF_UNKNOWN;
+ private static final byte PARENTREF_UNKNOWN = -1;
+ private static final byte PARENTREF_ABSENT = 0;
+ private static final byte PARENTREF_PRESENT = 1;
+
/**
* Acquire a reference on this context. As long as there is at least one reference outstanding,
* {@link #buildEffective()} will not result in {@link #effectiveSubstatements()} being discarded.
refcount = current - 1;
LOG.trace("Refcount {} on {}", refcount, this);
- if (isSweepable()) {
+
+ if (refcount == REFCOUNT_NONE) {
+ lastDecRef();
+ }
+ }
+
+ private void lastDecRef() {
+ if (noImplictRef()) {
// We are no longer guarded by effective instance
sweepOnDecrement();
+ return;
+ }
+
+ final byte prevRefs = parentRef;
+ if (prevRefs == PARENTREF_ABSENT) {
+ // We are the last reference towards root, any children who observed PARENTREF_PRESENT from us need to be
+ // updated
+ markNoParentRef();
+ } else if (prevRefs == PARENTREF_UNKNOWN) {
+ // Noone observed our parentRef, just update it
+ loadParentRefcount();
}
}
- /**
- * Sweep this statement context as a result of {@link #sweepSubstatements()}, i.e. when parent is also being swept.
- */
- private void sweep() {
- if (isSweepable()) {
- LOG.trace("Releasing {}", this);
- sweepState();
+ static final void markNoParentRef(final Collection<? extends ReactorStmtCtx<?, ?, ?>> substatements) {
+ for (ReactorStmtCtx<?, ?, ?> stmt : substatements) {
+ final byte prevRef = stmt.parentRef;
+ stmt.parentRef = PARENTREF_ABSENT;
+ if (prevRef == PARENTREF_PRESENT && stmt.refcount == REFCOUNT_NONE) {
+ // Child thinks it is pinned down, update its perspective
+ stmt.markNoParentRef();
+ }
}
}
+ abstract void markNoParentRef();
+
static final void sweep(final Collection<? extends ReactorStmtCtx<?, ?, ?>> substatements) {
for (ReactorStmtCtx<?, ?, ?> stmt : substatements) {
stmt.sweep();
}
}
+ /**
+ * Sweep this statement context as a result of {@link #sweepSubstatements()}, i.e. when parent is also being swept.
+ */
+ private void sweep() {
+ parentRef = PARENTREF_ABSENT;
+ if (refcount == REFCOUNT_NONE && noImplictRef()) {
+ LOG.trace("Releasing {}", this);
+ sweepState();
+ }
+ }
+
static final int countUnswept(final Collection<? extends ReactorStmtCtx<?, ?, ?>> substatements) {
int result = 0;
for (ReactorStmtCtx<?, ?, ?> stmt : substatements) {
// Called when this statement does not have an implicit reference and have reached REFCOUNT_NONE
private void sweepOnDecrement() {
LOG.trace("Sweeping on decrement {}", this);
- if (noParentRefcount()) {
+ if (noParentRef()) {
// No further parent references, sweep our state.
sweepState();
}
}
// parent is potentially reclaimable
- if (noParentRefcount()) {
+ if (noParentRef()) {
LOG.trace("Cleanup {} of parent {}", refcount, this);
if (sweepState()) {
final ReactorStmtCtx<?, ?, ?> parent = getParentContext();
return effectiveInstance != null || !isSupportedToBuildEffective();
}
- // FIXME: cache the resolution of this
- private boolean noParentRefcount() {
+ private boolean noParentRef() {
+ return parentRefcount() == PARENTREF_ABSENT;
+ }
+
+ private byte parentRefcount() {
+ final byte refs;
+ return (refs = parentRef) != PARENTREF_UNKNOWN ? refs : loadParentRefcount();
+ }
+
+ private byte loadParentRefcount() {
+ return parentRef = calculateParentRefcount();
+ }
+
+ private byte calculateParentRefcount() {
final ReactorStmtCtx<?, ?, ?> parent = getParentContext();
- if (parent != null) {
- // There are three possibilities:
- // - REFCOUNT_NONE, in which case we need to search next parent
- // - negative (< REFCOUNT_NONE), meaning parent is in some stage of sweeping, hence it does not have
- // a reference to us
- // - positive (> REFCOUNT_NONE), meaning parent has an explicit refcount which is holding us down
- final int refs = parent.refcount;
- return refs == REFCOUNT_NONE ? parent.noParentRefcount() : refs < REFCOUNT_NONE;
+ if (parent == null) {
+ return PARENTREF_ABSENT;
}
- return true;
+ // There are three possibilities:
+ // - REFCOUNT_NONE, in which case we need to search next parent
+ // - negative (< REFCOUNT_NONE), meaning parent is in some stage of sweeping, hence it does not have
+ // a reference to us
+ // - positive (> REFCOUNT_NONE), meaning parent has an explicit refcount which is holding us down
+ final int refs = parent.refcount;
+ if (refs == REFCOUNT_NONE) {
+ return parent.parentRefcount();
+ }
+ return refs < REFCOUNT_NONE ? PARENTREF_ABSENT : PARENTREF_PRESENT;
}
private boolean isAwaitingChildren() {
return refcount > REFCOUNT_SWEEPING && refcount < REFCOUNT_NONE;
}
- private boolean isSweepable() {
- return refcount == REFCOUNT_NONE && noImplictRef();
- }
-
private void sweepOnChildDone() {
LOG.trace("Sweeping on child done {}", this);
final int current = refcount;
Code Review / yangtools.git / blobdiff