X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-reactor%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Freactor%2FStatementContextBase.java;h=e51b39706cd78eb36987bab7032bd947cdfae6ba;hb=41ed305a7dce99e21a7b1066711347147dc067d8;hp=02443a920d468ae024b0f20e6a64826dc930b9ea;hpb=801a53da5a59219883bb1141d2e8191c11b65f47;p=yangtools.git diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java index 02443a920d..e51b39706c 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java @@ -8,8 +8,8 @@ package org.opendaylight.yangtools.yang.parser.stmt.reactor; import static com.google.common.base.Preconditions.checkArgument; -import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; +import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; @@ -18,7 +18,6 @@ import com.google.common.base.MoreObjects.ToStringHelper; import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMultimap; -import com.google.common.collect.ImmutableSet; import com.google.common.collect.Multimap; import com.google.common.collect.Multimaps; import java.util.ArrayList; @@ -28,37 +27,47 @@ import java.util.EnumMap; import java.util.EventListener; import java.util.Iterator; import java.util.List; +import java.util.Map; import java.util.Map.Entry; -import java.util.Objects; import java.util.Optional; import java.util.Set; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; -import org.opendaylight.yangtools.util.OptionalBoolean; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; -import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.common.YangVersion; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; +import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ConfigEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement; +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.CopyHistory; import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType; import org.opendaylight.yangtools.yang.parser.spi.meta.ImplicitParentAwareStatementSupport; +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.MutableStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour; +import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry; import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion; +import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceNotAvailableException; import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport; +import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport.CopyPolicy; 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.ImplicitSubstatement; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; -import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; -import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement; import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace; import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures; import org.opendaylight.yangtools.yang.parser.stmt.reactor.NamespaceBehaviourWithListeners.KeyedValueAddedListener; @@ -66,8 +75,15 @@ import org.opendaylight.yangtools.yang.parser.stmt.reactor.NamespaceBehaviourWit import org.slf4j.Logger; import org.slf4j.LoggerFactory; +/** + * Core reactor statement implementation of {@link Mutable}. + * + * @param Argument type + * @param Declared Statement representation + * @param Effective Statement representation + */ public abstract class StatementContextBase, E extends EffectiveStatement> - extends NamespaceStorageSupport implements Mutable, ResumedStatement { + extends NamespaceStorageSupport implements Mutable { /** * Event listener when an item is added to model namespace. */ @@ -98,67 +114,78 @@ public abstract class StatementContextBase, E private static final Logger LOG = LoggerFactory.getLogger(StatementContextBase.class); - private final @NonNull StatementDefinitionContext definition; - private final @NonNull StatementSourceReference statementDeclSource; - private final StmtContext originalCtx; - private final StmtContext prevCopyCtx; + // Flag bit assignments + private static final int IS_SUPPORTED_BY_FEATURES = 0x01; + private static final int HAVE_SUPPORTED_BY_FEATURES = 0x02; + private static final int IS_IGNORE_IF_FEATURE = 0x04; + private static final int HAVE_IGNORE_IF_FEATURE = 0x08; + // Note: these four are related + private static final int IS_IGNORE_CONFIG = 0x10; + private static final int HAVE_IGNORE_CONFIG = 0x20; + private static final int IS_CONFIGURATION = 0x40; + private static final int HAVE_CONFIGURATION = 0x80; + + // Have-and-set flag constants, also used as masks + private static final int SET_SUPPORTED_BY_FEATURES = HAVE_SUPPORTED_BY_FEATURES | IS_SUPPORTED_BY_FEATURES; + private static final int SET_CONFIGURATION = HAVE_CONFIGURATION | IS_CONFIGURATION; + // Note: implies SET_CONFIGURATION, allowing fewer bit operations to be performed + private static final int SET_IGNORE_CONFIG = HAVE_IGNORE_CONFIG | IS_IGNORE_CONFIG | SET_CONFIGURATION; + private static final int SET_IGNORE_IF_FEATURE = HAVE_IGNORE_IF_FEATURE | IS_IGNORE_IF_FEATURE; + private final CopyHistory copyHistory; - private final String rawArgument; + // Note: this field can strictly be derived in InferredStatementContext, but it forms the basis of many of our + // operations, hence we want to keep it close by. + private final @NonNull StatementDefinitionContext definition; private Multimap phaseListeners = ImmutableMultimap.of(); private Multimap phaseMutation = ImmutableMultimap.of(); - private List> effective = ImmutableList.of(); + + // Note: this field is accessed either directly, or under substatementsInitialized == true + private List> effective = ImmutableList.of(); + private List> effectOfStatement = ImmutableList.of(); - private StatementMap substatements = StatementMap.empty(); - private boolean isSupportedToBuildEffective = true; private @Nullable ModelProcessingPhase completedPhase; - private @Nullable D declaredInstance; private @Nullable E effectiveInstance; - // BooleanFields value - private byte supportedByFeatures; + // Master flag controlling whether this context can yield an effective statement + // FIXME: investigate the mechanics that are being supported by this, as it would be beneficial if we can get rid + // of this flag -- eliminating the initial alignment shadow used by below gap-filler fields. + private boolean isSupportedToBuildEffective = true; + // Flag for use with AbstractResumedStatement. This is hiding in the alignment shadow created by above boolean private boolean fullyDefined; - StatementContextBase(final StatementDefinitionContext def, final StatementSourceReference ref, - final String rawArgument) { - this.definition = requireNonNull(def); - this.statementDeclSource = requireNonNull(ref); - this.rawArgument = def.internArgument(rawArgument); - this.copyHistory = CopyHistory.original(); - this.originalCtx = null; - this.prevCopyCtx = null; - } + // Flag for InferredStatementContext. This is hiding in the alignment shadow created by above boolean. + private boolean substatementsInitialized; - StatementContextBase(final StatementDefinitionContext def, final StatementSourceReference ref, - final String rawArgument, final CopyType copyType) { - this.definition = requireNonNull(def); - this.statementDeclSource = requireNonNull(ref); - this.rawArgument = rawArgument; - this.copyHistory = CopyHistory.of(copyType, CopyHistory.original()); - this.originalCtx = null; - this.prevCopyCtx = null; - } + // Flags for use with SubstatementContext. These are hiding in the alignment shadow created by above boolean and + // hence improve memory layout. + private byte flags; - StatementContextBase(final StatementContextBase original, final CopyType copyType) { - this.definition = original.definition; - this.statementDeclSource = original.statementDeclSource; - this.rawArgument = original.rawArgument; - this.copyHistory = CopyHistory.of(copyType, original.getCopyHistory()); - this.originalCtx = original.getOriginalCtx().orElse(original); - this.prevCopyCtx = original; - } + // SchemaPath cache for use with SubstatementContext and InferredStatementContext. This hurts RootStatementContext + // a bit in terms of size -- but those are only a few and SchemaPath is on its way out anyway. + private SchemaPath schemaPath; + // Copy constructor used by subclasses to implement reparent() StatementContextBase(final StatementContextBase original) { + this.copyHistory = original.copyHistory; this.definition = original.definition; - this.statementDeclSource = original.statementDeclSource; - this.rawArgument = original.rawArgument; - this.copyHistory = original.getCopyHistory(); - this.originalCtx = original.getOriginalCtx().orElse(original); - this.prevCopyCtx = original; - this.substatements = original.substatements; - this.effective = original.effective; + + this.isSupportedToBuildEffective = original.isSupportedToBuildEffective; + this.fullyDefined = original.fullyDefined; + this.completedPhase = original.completedPhase; + this.flags = original.flags; + } + + StatementContextBase(final StatementDefinitionContext def) { + this.definition = requireNonNull(def); + this.copyHistory = CopyHistory.original(); + } + + StatementContextBase(final StatementDefinitionContext def, final CopyHistory copyHistory) { + this.definition = requireNonNull(def); + this.copyHistory = requireNonNull(copyHistory); } @Override @@ -188,44 +215,35 @@ public abstract class StatementContextBase, E @Override public boolean isSupportedByFeatures() { - if (OptionalBoolean.isPresent(supportedByFeatures)) { - return OptionalBoolean.get(supportedByFeatures); + final int fl = flags & SET_SUPPORTED_BY_FEATURES; + if (fl != 0) { + return fl == SET_SUPPORTED_BY_FEATURES; } - if (isIgnoringIfFeatures()) { - supportedByFeatures = OptionalBoolean.of(true); + flags |= SET_SUPPORTED_BY_FEATURES; return true; } - final boolean isParentSupported = isParentSupportedByFeatures(); /* - * If parent is not supported, then this context is also not supported. - * So we do not need to check if-features statements of this context and - * we can return false immediately. + * If parent is supported, we need to check if-features statements of this context. */ - if (!isParentSupported) { - supportedByFeatures = OptionalBoolean.of(false); - return false; + if (isParentSupportedByFeatures()) { + // If the set of supported features has not been provided, all features are supported by default. + final Set supportedFeatures = getFromNamespace(SupportedFeaturesNamespace.class, + SupportedFeatures.SUPPORTED_FEATURES); + if (supportedFeatures == null || StmtContextUtils.checkFeatureSupport(this, supportedFeatures)) { + flags |= SET_SUPPORTED_BY_FEATURES; + return true; + } } - /* - * If parent is supported, we need to check if-features statements of - * this context. - */ - // If the set of supported features has not been provided, all features are supported by default. - final Set supportedFeatures = getFromNamespace(SupportedFeaturesNamespace.class, - SupportedFeatures.SUPPORTED_FEATURES); - final boolean ret = supportedFeatures == null || StmtContextUtils.checkFeatureSupport(this, supportedFeatures); - supportedByFeatures = OptionalBoolean.of(ret); - return ret; + // Either parent is not supported or this statement is not supported + flags |= HAVE_SUPPORTED_BY_FEATURES; + return false; } protected abstract boolean isParentSupportedByFeatures(); - protected abstract boolean isIgnoringIfFeatures(); - - protected abstract boolean isIgnoringConfig(); - @Override public boolean isSupportedToBuildEffective() { return isSupportedToBuildEffective; @@ -241,23 +259,14 @@ public abstract class StatementContextBase, E return copyHistory; } - @Override - public Optional> getOriginalCtx() { - return Optional.ofNullable(originalCtx); - } - - @Override - public Optional> getPreviousCopyCtx() { - return Optional.ofNullable(prevCopyCtx); - } - @Override public ModelProcessingPhase getCompletedPhase() { return completedPhase; } - @Override - public void setCompletedPhase(final ModelProcessingPhase completedPhase) { + // FIXME: this should be propagated through a correct constructor + @Deprecated + final void setCompletedPhase(final ModelProcessingPhase completedPhase) { this.completedPhase = completedPhase; } @@ -272,48 +281,100 @@ public abstract class StatementContextBase, E @Override public abstract RootStatementContext getRoot(); - /** - * Returns the origin of the statement. - * - * @return origin of statement - */ @Override - public StatementSource getStatementSource() { - return statementDeclSource.getStatementSource(); + public final @NonNull Registry getBehaviourRegistry() { + return getRoot().getBehaviourRegistryImpl(); + } + + @Override + public final YangVersion getRootVersion() { + return getRoot().getRootVersionImpl(); } - /** - * Returns a reference to statement source. - * - * @return reference of statement source - */ @Override - public StatementSourceReference getStatementSourceReference() { - return statementDeclSource; + public final void setRootVersion(final YangVersion version) { + getRoot().setRootVersionImpl(version); } @Override - public final String rawStatementArgument() { - return rawArgument; + public final void addMutableStmtToSeal(final MutableStatement mutableStatement) { + getRoot().addMutableStmtToSealImpl(mutableStatement); } @Override - public Collection> declaredSubstatements() { - return substatements.values(); + public final void addRequiredSource(final SourceIdentifier dependency) { + getRoot().addRequiredSourceImpl(dependency); } @Override - public Collection> mutableDeclaredSubstatements() { - return substatements.values(); + public final void setRootIdentifier(final SourceIdentifier identifier) { + getRoot().setRootIdentifierImpl(identifier); } @Override - public Collection> effectiveSubstatements() { - return mutableEffectiveSubstatements(); + public final boolean isEnabledSemanticVersioning() { + return getRoot().isEnabledSemanticVersioningImpl(); } @Override - public Collection> mutableEffectiveSubstatements() { + public StatementSource getStatementSource() { + return getStatementSourceReference().getStatementSource(); + } + + @Override + public final > Map getAllFromCurrentStmtCtxNamespace( + final Class type) { + return getLocalNamespace(type); + } + + @Override + public final > Map getAllFromNamespace(final Class type) { + return getNamespace(type); + } + + /** + * Associate a value with a key within a namespace. + * + * @param type Namespace type + * @param key Key + * @param value value + * @param namespace key type + * @param namespace value type + * @param namespace type + * @param key type + * @param value type + * @throws NamespaceNotAvailableException when the namespace is not available. + */ + @Override + public final > void addToNs( + final Class<@NonNull N> type, final T key, final U value) { + addToNamespace(type, key, value); + } + + @Override + public abstract Collection> mutableDeclaredSubstatements(); + + /** + * Return a value associated with specified key within a namespace. + * + * @param type Namespace type + * @param key Key + * @param namespace key type + * @param namespace value type + * @param namespace type + * @param key type + * @return Value, or null if there is no element + * @throws NamespaceNotAvailableException when the namespace is not available. + */ + @Override + public final > V getFromNamespace( + final Class<@NonNull N> type, final T key) { + return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this, key); + } + + @Override + public final Collection> mutableEffectiveSubstatements() { + ensureEffectiveSubstatements(); if (effective instanceof ImmutableCollection) { return effective; } @@ -321,21 +382,16 @@ public abstract class StatementContextBase, E return Collections.unmodifiableCollection(effective); } - public void removeStatementsFromEffectiveSubstatements( - final Collection> statements) { - if (!effective.isEmpty()) { - effective.removeAll(statements); - shrinkEffective(); - } - } - private void shrinkEffective() { + // Initialization guarded by all callers if (effective.isEmpty()) { effective = ImmutableList.of(); } } - public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef) { + // Note: has side-effect of ensureEffectiveSubstatements() + public final void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef) { + ensureEffectiveSubstatements(); if (effective.isEmpty()) { return; } @@ -363,17 +419,20 @@ public abstract class StatementContextBase, E * @param statementDef statement definition of the statement context to remove * @param statementArg statement argument of the statement context to remove */ - public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef, + public final void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef, final String statementArg) { if (statementArg == null) { + // Note: has side-effect of ensureEffectiveSubstatements() removeStatementFromEffectiveSubstatements(statementDef); + } else { + ensureEffectiveSubstatements(); } if (effective.isEmpty()) { return; } - final Iterator> iterator = effective.iterator(); + final Iterator> iterator = effective.iterator(); while (iterator.hasNext()) { final Mutable next = iterator.next(); if (statementDef.equals(next.getPublicDefinition()) && statementArg.equals(next.rawStatementArgument())) { @@ -384,6 +443,19 @@ public abstract class StatementContextBase, E shrinkEffective(); } + // YANG example: RPC/action statements always have 'input' and 'output' defined + @Beta + public , Z extends EffectiveStatement> @NonNull Mutable + appendImplicitSubstatement(final StatementSupport support, final String rawArg) { + // FIXME: YANGTOOLS-652: This does not need to be a SubstatementContext, in can be a specialized + // StatementContextBase subclass. + final Mutable ret = new SubstatementContext<>(this, new StatementDefinitionContext<>(support), + ImplicitSubstatement.of(getStatementSourceReference()), rawArg); + support.onStatementAdded(ret); + addEffectiveSubstatement(ret); + return ret; + } + /** * Adds an effective statement to collection of substatements. * @@ -393,9 +465,17 @@ public abstract class StatementContextBase, E * @throws NullPointerException * if statement parameter is null */ - public void addEffectiveSubstatement(final Mutable substatement) { + public final void addEffectiveSubstatement(final Mutable substatement) { + verifyStatement(substatement); + ensureEffectiveSubstatements(); beforeAddEffectiveStatement(1); - effective.add(substatement); + + final StatementContextBase stmt = (StatementContextBase) substatement; + final ModelProcessingPhase phase = completedPhase; + if (phase != null) { + ensureCompletedPhase(stmt, phase); + } + effective.add(stmt); } /** @@ -407,161 +487,170 @@ public abstract class StatementContextBase, E * @throws NullPointerException * if statement parameter is null */ - public void addEffectiveSubstatements(final Collection> statements) { - if (statements.isEmpty()) { - return; + public final void addEffectiveSubstatements(final Collection> statements) { + if (!statements.isEmpty()) { + statements.forEach(StatementContextBase::verifyStatement); + ensureEffectiveSubstatements(); + beforeAddEffectiveStatement(statements.size()); + doAddEffectiveSubstatements(statements); } + } - statements.forEach(Objects::requireNonNull); - beforeAddEffectiveStatement(statements.size()); - effective.addAll(statements); + // exposed for InferredStatementContext, which we expect to initialize effective substatements + void ensureEffectiveSubstatements() { + // No-op for everything except InferredStatementContext } - private void beforeAddEffectiveStatement(final int toAdd) { - final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase(); - checkState(inProgressPhase == ModelProcessingPhase.FULL_DECLARATION - || inProgressPhase == ModelProcessingPhase.EFFECTIVE_MODEL, - "Effective statement cannot be added in declared phase at: %s", getStatementSourceReference()); + // Exposed for InferredStatementContextr only, others do not need initialization + Iterable> effectiveChildrenToComplete() { + return effective; + } - if (effective.isEmpty()) { - effective = new ArrayList<>(toAdd); + // exposed for InferredStatementContext only + final void addInitialEffectiveSubstatements(final Collection> statements) { + verify(!substatementsInitialized, "Attempted to re-initialized statement {} with {}", this, statements); + substatementsInitialized = true; + + if (!statements.isEmpty()) { + statements.forEach(StatementContextBase::verifyStatement); + beforeAddEffectiveStatementUnsafe(statements.size()); + doAddEffectiveSubstatements(statements); } } - /** - * Create a new substatement at the specified offset. - * - * @param offset Substatement offset - * @param def definition context - * @param ref source reference - * @param argument statement argument - * @param new substatement argument type - * @param new substatement declared type - * @param new substatement effective type - * @return A new substatement - */ - @SuppressWarnings("checkstyle:methodTypeParameterName") - public final , Z extends EffectiveStatement> - StatementContextBase createSubstatement(final int offset, - final StatementDefinitionContext def, final StatementSourceReference ref, - final String argument) { - final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase(); - checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL, - "Declared statement cannot be added in effective phase at: %s", getStatementSourceReference()); - - final Optional> implicitParent = definition.getImplicitParentFor(def.getPublicView()); - if (implicitParent.isPresent()) { - return createImplicitParent(offset, implicitParent.get(), ref, argument).createSubstatement(offset, def, - ref, argument); + private void doAddEffectiveSubstatements(final Collection> statements) { + final Collection> casted = + (Collection>) statements; + final ModelProcessingPhase phase = completedPhase; + if (phase != null) { + for (StatementContextBase stmt : casted) { + ensureCompletedPhase(stmt, phase); + } } - final StatementContextBase ret = new SubstatementContext<>(this, def, ref, argument); - substatements = substatements.put(offset, ret); - def.onStatementAdded(ret); - return ret; + // Initialization guarded by all callers + effective.addAll(casted); } - private StatementContextBase createImplicitParent(final int offset, - final StatementSupport implicitParent, final StatementSourceReference ref, final String argument) { - final StatementDefinitionContext def = new StatementDefinitionContext<>(implicitParent); - return createSubstatement(offset, def, ImplicitSubstatement.of(ref), argument); + // Make sure target statement has transitioned at least to specified phase. This method is just before we take + // allow a statement to become our substatement. This is needed to ensure that every statement tree does not contain + // any statements which did not complete the same phase as the root statement. + private static void ensureCompletedPhase(final StatementContextBase stmt, + final ModelProcessingPhase phase) { + verify(stmt.tryToCompletePhase(phase), "Statement %s cannot complete phase %s", stmt, phase); } - public void appendImplicitStatement(final StatementSupport statementToAdd) { - createSubstatement(substatements.capacity(), new StatementDefinitionContext<>(statementToAdd), - ImplicitSubstatement.of(getStatementSourceReference()), null); + private static void verifyStatement(final Mutable stmt) { + verify(stmt instanceof StatementContextBase, "Unexpected statement %s", stmt); } - /** - * Lookup substatement by its offset in this statement. - * - * @param offset Substatement offset - * @return Substatement, or null if substatement does not exist. - */ - final StatementContextBase lookupSubstatement(final int offset) { - return substatements.get(offset); + private void beforeAddEffectiveStatement(final int toAdd) { + // We cannot allow statement to be further mutated + verify(completedPhase != ModelProcessingPhase.EFFECTIVE_MODEL, "Cannot modify finished statement at %s", + getStatementSourceReference()); + beforeAddEffectiveStatementUnsafe(toAdd); } - final void setFullyDefined() { - this.fullyDefined = true; + private void beforeAddEffectiveStatementUnsafe(final int toAdd) { + final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase(); + checkState(inProgressPhase == ModelProcessingPhase.FULL_DECLARATION + || inProgressPhase == ModelProcessingPhase.EFFECTIVE_MODEL, + "Effective statement cannot be added in declared phase at: %s", getStatementSourceReference()); + + // Initialization guarded by all callers + if (effective.isEmpty()) { + effective = new ArrayList<>(toAdd); + } + } + + // These two exists only due to memory optimization, should live in AbstractResumedStatement + final boolean fullyDefined() { + return fullyDefined; } - final void resizeSubstatements(final int expectedSize) { - substatements = substatements.ensureCapacity(expectedSize); + final void setFullyDefined() { + fullyDefined = true; } - final void walkChildren(final ModelProcessingPhase phase) { - checkState(fullyDefined); - substatements.values().forEach(stmt -> { - stmt.walkChildren(phase); - stmt.endDeclared(phase); - }); + // These two exist only due to memory optimization, should live in InferredStatementContext + final boolean substatementsInitialized() { + return substatementsInitialized; } - @Override - public D buildDeclared() { - checkArgument(completedPhase == ModelProcessingPhase.FULL_DECLARATION - || completedPhase == ModelProcessingPhase.EFFECTIVE_MODEL); - if (declaredInstance == null) { - declaredInstance = definition().getFactory().createDeclared(this); - } - return declaredInstance; + final void setSubstatementsInitialized() { + substatementsInitialized = true; } @Override public E buildEffective() { - if (effectiveInstance == null) { - effectiveInstance = definition().getFactory().createEffective(this); - } - return effectiveInstance; + final E existing; + return (existing = effectiveInstance) != null ? existing : loadEffective(); + } + + private E loadEffective() { + return effectiveInstance = definition.getFactory().createEffective(this); } /** - * tries to execute current {@link ModelProcessingPhase} of source parsing. + * 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 if phase was successfully completed - * @throws SourceException - * when an error occurred in source parsing + * @param phase to be executed (completed) + * @return true if phase was successfully completed + * @throws SourceException when an error occurred in source parsing */ - boolean tryToCompletePhase(final ModelProcessingPhase phase) { + final boolean tryToCompletePhase(final ModelProcessingPhase phase) { + return phase.isCompletedBy(completedPhase) || doTryToCompletePhase(phase); + } + + private boolean doTryToCompletePhase(final ModelProcessingPhase phase) { + final boolean finished = phaseMutation.isEmpty() ? true : runMutations(phase); + if (completeChildren(phase) && finished) { + onPhaseCompleted(phase); + return true; + } + return false; + } + private boolean completeChildren(final ModelProcessingPhase phase) { boolean finished = true; + for (final StatementContextBase child : mutableDeclaredSubstatements()) { + finished &= child.tryToCompletePhase(phase); + } + for (final StatementContextBase child : effectiveChildrenToComplete()) { + finished &= child.tryToCompletePhase(phase); + } + return finished; + } + + private boolean runMutations(final ModelProcessingPhase phase) { final Collection openMutations = phaseMutation.get(phase); - if (!openMutations.isEmpty()) { - final Iterator it = openMutations.iterator(); - while (it.hasNext()) { - final ContextMutation current = it.next(); - if (current.isFinished()) { - it.remove(); - } else { - finished = false; - } - } + return openMutations.isEmpty() ? true : runMutations(phase, openMutations); + } - if (openMutations.isEmpty()) { - phaseMutation.removeAll(phase); - if (phaseMutation.isEmpty()) { - phaseMutation = ImmutableMultimap.of(); - } + private boolean runMutations(final ModelProcessingPhase phase, final Collection openMutations) { + boolean finished = true; + final Iterator it = openMutations.iterator(); + while (it.hasNext()) { + final ContextMutation current = it.next(); + if (current.isFinished()) { + it.remove(); + } else { + finished = false; } } - for (final StatementContextBase child : substatements.values()) { - finished &= child.tryToCompletePhase(phase); - } - for (final Mutable child : effective) { - if (child instanceof StatementContextBase) { - finished &= ((StatementContextBase) child).tryToCompletePhase(phase); - } + if (openMutations.isEmpty()) { + phaseMutation.removeAll(phase); + cleanupPhaseMutation(); } + return finished; + } - if (finished) { - onPhaseCompleted(phase); - return true; + private void cleanupPhaseMutation() { + if (phaseMutation.isEmpty()) { + phaseMutation = ImmutableMultimap.of(); } - return false; } /** @@ -576,10 +665,12 @@ public abstract class StatementContextBase, E completedPhase = phase; final Collection listeners = phaseListeners.get(phase); - if (listeners.isEmpty()) { - return; + if (!listeners.isEmpty()) { + runPhaseListeners(phase, listeners); } + } + private void runPhaseListeners(final ModelProcessingPhase phase, final Collection listeners) { final Iterator listener = listeners.iterator(); while (listener.hasNext()) { final OnPhaseFinished next = listener.next(); @@ -600,7 +691,7 @@ public abstract class StatementContextBase, E * Ends declared section of current node. */ void endDeclared(final ModelProcessingPhase phase) { - definition().onDeclarationFinished(this, phase); + definition.onDeclarationFinished(this, phase); } /** @@ -614,7 +705,7 @@ public abstract class StatementContextBase, E @Override protected void checkLocalNamespaceAllowed(final Class> type) { - definition().checkNamespaceAllowed(type); + definition.checkNamespaceAllowed(type); } @Override @@ -694,12 +785,9 @@ public abstract class StatementContextBase, E return (NamespaceBehaviourWithListeners) behaviour; } - /** - * See {@link StatementSupport#getPublicView()}. - */ @Override public StatementDefinition getPublicDefinition() { - return definition().getPublicView(); + return definition.getPublicView(); } @Override @@ -720,8 +808,8 @@ public abstract class StatementContextBase, E * @throws NullPointerException if any of the arguments is null */ void addPhaseCompletedListener(final ModelProcessingPhase phase, final OnPhaseFinished listener) { - checkNotNull(phase, "Statement context processing phase cannot be null at: %s", getStatementSourceReference()); - checkNotNull(listener, "Statement context phase listener cannot be null at: %s", getStatementSourceReference()); + requireNonNull(phase, "Statement context processing phase cannot be null"); + requireNonNull(listener, "Statement context phase listener cannot be null"); ModelProcessingPhase finishedPhase = completedPhase; while (finishedPhase != null) { @@ -741,10 +829,9 @@ public abstract class StatementContextBase, E /** * Adds a {@link ContextMutation} to a {@link ModelProcessingPhase}. * - * @throws IllegalStateException - * when the mutation was registered after phase was completed + * @throws IllegalStateException when the mutation was registered after phase was completed */ - void addMutation(final ModelProcessingPhase phase, final ContextMutation mutation) { + final void addMutation(final ModelProcessingPhase phase, final ContextMutation mutation) { ModelProcessingPhase finishedPhase = completedPhase; while (finishedPhase != null) { checkState(!phase.equals(finishedPhase), "Mutation registered after phase was completed at: %s", @@ -758,30 +845,70 @@ public abstract class StatementContextBase, E phaseMutation.put(phase, mutation); } + final void removeMutation(final ModelProcessingPhase phase, final ContextMutation mutation) { + if (!phaseMutation.isEmpty()) { + phaseMutation.remove(phase, mutation); + cleanupPhaseMutation(); + } + } + @Override - public > void addContext(final Class namespace, + public > void addContext(final Class<@NonNull N> namespace, final KT key,final StmtContext stmt) { addContextToNamespace(namespace, key, stmt); } @Override - public , Z extends EffectiveStatement> Mutable childCopyOf( - final StmtContext stmt, final CopyType type, final QNameModule targetModule) { - checkState(stmt.getCompletedPhase() == ModelProcessingPhase.EFFECTIVE_MODEL, - "Attempted to copy statement %s which has completed phase %s", stmt, stmt.getCompletedPhase()); + public Optional> copyAsChildOf(final Mutable parent, final CopyType type, + final QNameModule targetModule) { + checkEffectiveModelCompleted(this); + + final StatementSupport support = definition.support(); + final CopyPolicy policy = support.applyCopyPolicy(this, parent, type, targetModule); + switch (policy) { + case CONTEXT_INDEPENDENT: + if (hasEmptySubstatements()) { + // This statement is context-independent and has no substatements -- hence it can be freely shared. + return Optional.of(this); + } + // FIXME: YANGTOOLS-694: filter out all context-independent substatements, eliminate fall-through + // fall through + case DECLARED_COPY: + // FIXME: YANGTOOLS-694: this is still to eager, we really want to copy as a lazily-instantiated + // context, so that we can support building an effective statement without copying + // anything -- we will typically end up not being inferred against. In that case, + // this slim context should end up dealing with differences at buildContext() + // time. This is a YANGTOOLS-1067 prerequisite (which will deal with what can and + // cannot be shared across instances). + return Optional.of(parent.childCopyOf(this, type, targetModule)); + case IGNORE: + return Optional.empty(); + case REJECT: + throw new IllegalStateException("Statement " + support.getPublicView() + " should never be copied"); + default: + throw new IllegalStateException("Unhandled policy " + policy); + } + } - checkArgument(stmt instanceof SubstatementContext, "Unsupported statement %s", stmt); + @Override + public final Mutable childCopyOf(final StmtContext stmt, final CopyType type, + final QNameModule targetModule) { + checkEffectiveModelCompleted(stmt); + checkArgument(stmt instanceof StatementContextBase, "Unsupported statement %s", stmt); + return childCopyOf((StatementContextBase) stmt, type, targetModule); + } - final SubstatementContext original = (SubstatementContext)stmt; + private , Z extends EffectiveStatement> Mutable childCopyOf( + final StatementContextBase original, final CopyType type, final QNameModule targetModule) { final Optional> implicitParent = definition.getImplicitParentFor( original.getPublicDefinition()); - final SubstatementContext result; - final SubstatementContext copy; + final StatementContextBase result; + final InferredStatementContext copy; if (implicitParent.isPresent()) { final StatementDefinitionContext def = new StatementDefinitionContext<>(implicitParent.get()); - result = new SubstatementContext(this, def, original.getSourceReference(), + result = new SubstatementContext(this, def, original.getStatementSourceReference(), original.rawStatementArgument(), original.getStatementArgument(), type); final CopyType childCopyType; @@ -798,31 +925,20 @@ public abstract class StatementContextBase, E childCopyType = type; } - copy = new SubstatementContext<>(original, result, childCopyType, targetModule); + copy = new InferredStatementContext<>(result, original, childCopyType, type, targetModule); result.addEffectiveSubstatement(copy); - original.definition().onStatementAdded(copy); } else { - result = copy = new SubstatementContext<>(original, this, type, targetModule); - original.definition().onStatementAdded(copy); + result = copy = new InferredStatementContext<>(this, original, type, type, targetModule); } - original.copyTo(copy, type, targetModule); + original.definition.onStatementAdded(copy); return result; } - @Override - public @NonNull StatementDefinition getDefinition() { - return getPublicDefinition(); - } - - @Override - public @NonNull StatementSourceReference getSourceReference() { - return getStatementSourceReference(); - } - - @Override - public boolean isFullyDefined() { - return fullyDefined; + private static void checkEffectiveModelCompleted(final StmtContext stmt) { + final ModelProcessingPhase phase = stmt.getCompletedPhase(); + checkState(phase == ModelProcessingPhase.EFFECTIVE_MODEL, + "Attempted to copy statement %s which has completed phase %s", stmt, phase); } @Beta @@ -844,68 +960,158 @@ public abstract class StatementContextBase, E original.getStatementSourceReference(), original.rawStatementArgument(), original.getStatementArgument(), type); - result.addEffectiveSubstatement(new SubstatementContext<>(original, result)); + result.addEffectiveSubstatement(original.reparent(result)); result.setCompletedPhase(original.getCompletedPhase()); return result; } - final void copyTo(final StatementContextBase target, final CopyType typeOfCopy, - @Nullable final QNameModule targetModule) { - final Collection> buffer = new ArrayList<>(substatements.size() + effective.size()); + abstract StatementContextBase reparent(StatementContextBase newParent); - for (final Mutable stmtContext : substatements.values()) { - if (stmtContext.isSupportedByFeatures()) { - copySubstatement(stmtContext, target, typeOfCopy, targetModule, buffer); - } + /** + * Indicate that the set of substatements is empty. This is a preferred shortcut to substatement stream filtering. + * + * @return True if {@link #allSubstatements()} and {@link #allSubstatementsStream()} would return an empty stream. + */ + abstract boolean hasEmptySubstatements(); + + // Dual use method: AbstractResumedStatement does not use 'initialized' and InferredStatementContext ensures + // initialization. + // FIXME: 7.0.0: I think this warrants a separate subclasses, as InferredStatementContext wants to manage these + // itself. Before we do that, though, we need to analyze size impacts + final boolean hasEmptyEffectiveSubstatements() { + return effective.isEmpty(); + } + + /** + * Config statements are not all that common which means we are performing a recursive search towards the root + * every time {@link #isConfiguration()} is invoked. This is quite expensive because it causes a linear search + * for the (usually non-existent) config statement. + * + *

+ * This method maintains a resolution cache, so once we have returned a result, we will keep on returning the same + * result without performing any lookups, solely to support {@link SubstatementContext#isConfiguration()}. + * + *

+ * Note: use of this method implies that {@link #isIgnoringConfig()} is realized with + * {@link #isIgnoringConfig(StatementContextBase)}. + */ + final boolean isConfiguration(final StatementContextBase parent) { + final int fl = flags & SET_CONFIGURATION; + if (fl != 0) { + return fl == SET_CONFIGURATION; + } + if (isIgnoringConfig(parent)) { + // Note: SET_CONFIGURATION has been stored in flags + return true; } - for (final Mutable stmtContext : effective) { - copySubstatement(stmtContext, target, typeOfCopy, targetModule, buffer); + final boolean isConfig; + final Optional optConfig = findSubstatementArgument(ConfigEffectiveStatement.class); + if (optConfig.isPresent()) { + isConfig = optConfig.orElseThrow(); + if (isConfig) { + // Validity check: if parent is config=false this cannot be a config=true + InferenceException.throwIf(!parent.isConfiguration(), getStatementSourceReference(), + "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(); } - target.addEffectiveSubstatements(buffer); + // Resolved, make sure we cache this return + flags |= isConfig ? SET_CONFIGURATION : HAVE_CONFIGURATION; + return isConfig; } - private void copySubstatement(final Mutable stmtContext, final Mutable target, - final CopyType typeOfCopy, final QNameModule newQNameModule, final Collection> buffer) { - if (needToCopyByUses(stmtContext)) { - final Mutable copy = target.childCopyOf(stmtContext, typeOfCopy, newQNameModule); - LOG.debug("Copying substatement {} for {} as {}", stmtContext, this, copy); - buffer.add(copy); - } else if (isReusedByUses(stmtContext)) { - LOG.debug("Reusing substatement {} for {}", stmtContext, this); - buffer.add(stmtContext); - } else { - LOG.debug("Skipping statement {}", stmtContext); + protected abstract boolean isIgnoringConfig(); + + /** + * This method maintains a resolution cache for ignore config, so once we have returned a result, we will + * keep on returning the same result without performing any lookups. Exists only to support + * {@link SubstatementContext#isIgnoringConfig()}. + * + *

+ * Note: use of this method implies that {@link #isConfiguration()} is realized with + * {@link #isConfiguration(StatementContextBase)}. + */ + final boolean isIgnoringConfig(final StatementContextBase parent) { + final int fl = flags & SET_IGNORE_CONFIG; + if (fl != 0) { + return fl == SET_IGNORE_CONFIG; } + if (definition.support().isIgnoringConfig() || parent.isIgnoringConfig()) { + flags |= SET_IGNORE_CONFIG; + return true; + } + + flags |= HAVE_IGNORE_CONFIG; + return false; } - // FIXME: revise this, as it seems to be wrong - private static final ImmutableSet NOCOPY_FROM_GROUPING_SET = ImmutableSet.of( - YangStmtMapping.DESCRIPTION, - YangStmtMapping.REFERENCE, - YangStmtMapping.STATUS); - private static final ImmutableSet REUSED_DEF_SET = ImmutableSet.of( - YangStmtMapping.TYPE, - YangStmtMapping.TYPEDEF, - YangStmtMapping.USES); + protected abstract boolean isIgnoringIfFeatures(); - private static boolean needToCopyByUses(final StmtContext stmtContext) { - final StatementDefinition def = stmtContext.getPublicDefinition(); - if (REUSED_DEF_SET.contains(def)) { - LOG.debug("Will reuse {} statement {}", def, stmtContext); - return false; + /** + * This method maintains a resolution cache for ignore if-feature, so once we have returned a result, we will + * keep on returning the same result without performing any lookups. Exists only to support + * {@link SubstatementContext#isIgnoringIfFeatures()}. + */ + final boolean isIgnoringIfFeatures(final StatementContextBase parent) { + final int fl = flags & SET_IGNORE_IF_FEATURE; + if (fl != 0) { + return fl == SET_IGNORE_IF_FEATURE; } - if (NOCOPY_FROM_GROUPING_SET.contains(def)) { - return !YangStmtMapping.GROUPING.equals(stmtContext.coerceParentContext().getPublicDefinition()); + if (definition.support().isIgnoringIfFeatures() || parent.isIgnoringIfFeatures()) { + flags |= SET_IGNORE_IF_FEATURE; + return true; } - LOG.debug("Will copy {} statement {}", def, stmtContext); - return true; + flags |= HAVE_IGNORE_IF_FEATURE; + return false; } - private static boolean isReusedByUses(final StmtContext stmtContext) { - return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition()); + // Exists only to support {SubstatementContext,InferredStatementContext}.getSchemaPath() + @Deprecated + final @NonNull Optional substatementGetSchemaPath() { + if (schemaPath == null) { + schemaPath = createSchemaPath(coerceParentContext()); + } + return Optional.ofNullable(schemaPath); + } + + @Deprecated + private SchemaPath createSchemaPath(final Mutable parent) { + final Optional maybeParentPath = parent.getSchemaPath(); + verify(maybeParentPath.isPresent(), "Parent %s does not have a SchemaPath", parent); + final SchemaPath parentPath = maybeParentPath.get(); + + if (StmtContextUtils.isUnknownStatement(this)) { + return parentPath.createChild(getPublicDefinition().getStatementName()); + } + final Object argument = getStatementArgument(); + if (argument instanceof QName) { + final QName qname = (QName) argument; + if (producesDeclared(UsesStatement.class)) { + return maybeParentPath.orElse(null); + } + + return parentPath.createChild(qname); + } + if (argument instanceof String) { + // FIXME: This may yield illegal argument exceptions + final Optional> originalCtx = getOriginalCtx(); + final QName qname = StmtContextUtils.qnameFromArgument(originalCtx.orElse(this), (String) argument); + return parentPath.createChild(qname); + } + if (argument instanceof SchemaNodeIdentifier + && (producesDeclared(AugmentStatement.class) || producesDeclared(RefineStatement.class) + || producesDeclared(DeviationStatement.class))) { + + return parentPath.createChild(((SchemaNodeIdentifier) argument).getNodeIdentifiers()); + } + + // FIXME: this does not look right + return maybeParentPath.orElse(null); } @Override @@ -914,6 +1120,6 @@ public abstract class StatementContextBase, E } protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) { - return toStringHelper.add("definition", definition).add("rawArgument", rawArgument); + return toStringHelper.add("definition", definition).add("rawArgument", rawStatementArgument()); } }