private final @NonNull StatementSourceReference statementDeclSource;
private final String rawArgument;
- private List<StatementContextBase<?, ?, ?>> effective = ImmutableList.of();
+ private List<ReactorStmtCtx<?, ?, ?>> effective = ImmutableList.of();
private StatementMap substatements = StatementMap.empty();
private @Nullable D declaredInstance;
}
@Override
- final Iterable<StatementContextBase<?, ?, ?>> effectiveChildrenToComplete() {
+ final Iterable<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete() {
return effective;
}
// Instantiate this statement's effective substatements. Note this method has side-effects in namespaces and overall
// BuildGlobalContext, hence it must be called at most once.
- private List<StatementContextBase<?, ?, ?>> ensureEffectiveSubstatements() {
+ private List<ReactorStmtCtx<?, ?, ?>> ensureEffectiveSubstatements() {
accessSubstatements();
return substatements instanceof List ? castEffective(substatements)
: initializeSubstatements(castMaterialized(substatements));
}
@Override
- Iterable<StatementContextBase<?, ?, ?>> effectiveChildrenToComplete() {
+ Iterable<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete() {
// When we have not initialized, there are no statements to catch up: we will catch up when we are copying
// from prototype (which is already at ModelProcessingPhase.EFFECTIVE_MODEL).
if (substatements == null) {
substatements = SWEPT_SUBSTATEMENTS;
int count = 0;
if (local != null) {
- final List<StatementContextBase<?, ?, ?>> list = castEffective(local);
+ final List<ReactorStmtCtx<?, ?, ?>> list = castEffective(local);
sweep(list);
count = countUnswept(list);
}
return count;
}
- private List<StatementContextBase<?, ?, ?>> initializeSubstatements(
- final Map<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>> materializedSchemaTree) {
+ private List<ReactorStmtCtx<?, ?, ?>> initializeSubstatements(
+ final Map<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> materializedSchemaTree) {
final Collection<? extends StatementContextBase<?, ?, ?>> declared = prototype.mutableDeclaredSubstatements();
final Collection<? extends Mutable<?, ?, ?>> effective = prototype.mutableEffectiveSubstatements();
copySubstatement(stmtContext, buffer, materializedSchemaTree);
}
- final List<StatementContextBase<?, ?, ?>> ret = beforeAddEffectiveStatementUnsafe(ImmutableList.of(),
- buffer.size());
+ final List<ReactorStmtCtx<?, ?, ?>> ret = beforeAddEffectiveStatementUnsafe(ImmutableList.of(), buffer.size());
ret.addAll((Collection) buffer);
substatements = ret;
YangStmtMapping.USES);
private void copySubstatement(final Mutable<?, ?, ?> substatement, final Collection<Mutable<?, ?, ?>> buffer,
- final Map<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>> materializedSchemaTree) {
+ final Map<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> materializedSchemaTree) {
final StatementDefinition def = substatement.publicDefinition();
// FIXME: YANGTOOLS-652: formerly known as "isReusedByUses"
//
// We could also perform a Map.containsKey() and perform a bulk add, but that would mean the statement order
// against parent would change -- and we certainly do not want that to happen.
- final StatementContextBase<?, ?, ?> materialized = findMaterialized(materializedSchemaTree, substatement);
+ final ReactorStmtCtx<?, ?, ?> materialized = findMaterialized(materializedSchemaTree, substatement);
if (materialized == null) {
copySubstatement(substatement).ifPresent(copy -> {
ensureCompletedPhase(copy);
}
private void addMaterialized(final StmtContext<?, ?, ?> template, final Mutable<?, ?, ?> copy) {
- final HashMap<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>> materializedSchemaTree;
+ final HashMap<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> materializedSchemaTree;
if (substatements == null) {
// Lazy initialization of backing map. We do not expect this to be used often or multiple times -- each hit
// here means an inference along schema tree, such as deviate/augment. HashMap requires power-of-two and
}
}
- private static @Nullable StatementContextBase<?, ?, ?> findMaterialized(
- final Map<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>> materializedSchemaTree,
+ private static @Nullable ReactorStmtCtx<?, ?, ?> findMaterialized(
+ final Map<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> materializedSchemaTree,
final StmtContext<?, ?, ?> template) {
return materializedSchemaTree == null ? null : materializedSchemaTree.get(template);
}
@SuppressWarnings("unchecked")
- private static List<StatementContextBase<?, ?, ?>> castEffective(final Object substatements) {
- return (List<StatementContextBase<?, ?, ?>>) substatements;
+ private static List<ReactorStmtCtx<?, ?, ?>> castEffective(final Object substatements) {
+ return (List<ReactorStmtCtx<?, ?, ?>>) substatements;
}
@SuppressWarnings("unchecked")
- private static HashMap<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>> castMaterialized(
- final Object substatements) {
- return (HashMap<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>>) substatements;
+ private static HashMap<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> castMaterialized(final Object substatements) {
+ return (HashMap<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>>) substatements;
}
// Statement copy mess ends here
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;
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
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Optional;
-import java.util.stream.Stream;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QNameModule;
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.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
+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.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
* designated source.
*/
final class ReplicaStatementContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
- extends
StatementContextBase<A, D, E> {
+ extends
ReactorStmtCtx<A, D, E> {
private final StatementContextBase<?, ?, ?> parent;
- private final
StatementContextBase<A, D, E> source;
+ private final
ReactorStmtCtx<A, D, E> source;
- ReplicaStatementContext(final StatementContextBase<?, ?, ?> parent, final
StatementContextBase<A, D, E> source) {
+ ReplicaStatementContext(final StatementContextBase<?, ?, ?> parent, final
ReactorStmtCtx<A, D, E> source) {
super(source);
this.parent = requireNonNull(parent);
this.source = requireNonNull(source);
}
@Override
- boolean hasEmptySubstatements() {
- return source.hasEmptySubstatements();
+ public ModelProcessingPhase getCompletedPhase() {
+ return source.getCompletedPhase();
}
@Override
- Iterable<StatementContextBase<?, ?, ?>> effectiveChildrenToComplete() {
- return ImmutableList.of();
+ public CopyHistory history() {
+ return source.history();
+ }
+
+ @Override
+ public Mutable<A, D, E> replicaAsChildOf(final Mutable<?, ?, ?> newParent) {
+ return source.replicaAsChildOf(newParent);
+ }
+
+ @Override
+ public Optional<? extends Mutable<?, ?, ?>> copyAsChildOf(final Mutable<?, ?, ?> newParent, final CopyType type,
+ final QNameModule targetModule) {
+ return source.copyAsChildOf(newParent, type, targetModule);
+ }
+
+ @Override
+ StatementDefinitionContext<A, D, E> definition() {
+ return source.definition();
}
@Override
}
@Override
- public Optional<StmtContext<A, D, E>> getPreviousCopyCtx() {
+ public <K, V, T extends K, U extends V, N extends IdentifierNamespace<K, V>> void addToNs(
+ final Class<@NonNull N> type, final T key, final U value) {
throw new UnsupportedOperationException();
}
@Override
- public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef) {
+ public Optional<StmtContext<A, D, E>> getPreviousCopyCtx() {
throw new UnsupportedOperationException();
}
@Override
- public void removeStatementFromEffectiveSubstatements(final StatementDefinition statementDef,
- final String statementArg) {
+ public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final Class<@NonNull N> namespace,
+ final KT key, final StmtContext<?, ?, ?> stmt) {
throw new UnsupportedOperationException();
}
@Override
- public void addEffectiveSubstatement(final Mutable<?, ?, ?> substatement) {
+ public void addAsEffectOfStatement(final StmtContext<?, ?, ?> ctx) {
throw new UnsupportedOperationException();
}
@Override
- void addEffectiveSubstatementsImpl(final Collection<? extends Mutable<?, ?, ?>> statements) {
+ public void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
throw new UnsupportedOperationException();
}
@Override
- Stream<? extends StmtContext<?, ?, ?>> streamDeclared() {
+ public Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement() {
throw new UnsupportedOperationException();
}
@Override
- Stream<? extends StmtContext<?, ?, ?>> streamEffective() {
+ public Mutable<?, ?, ?> childCopyOf(final StmtContext<?, ?, ?> stmt, final CopyType type,
+ final QNameModule targetModule) {
throw new UnsupportedOperationException();
}
- @Override
- StatementContextBase<A, D, E> reparent(final StatementContextBase<?, ?, ?> newParent) {
+ @Override boolean doTryToCompletePhase(final ModelProcessingPhase phase) {
throw new UnsupportedOperationException();
}
}
@Override
- public CopyHistory history() {
+ public final CopyHistory history() {
return copyHistory;
}
@Override
- public ModelProcessingPhase getCompletedPhase() {
+ public final ModelProcessingPhase getCompletedPhase() {
return completedPhase;
}
}
static final Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements(
- final List<StatementContextBase<?, ?, ?>> effective) {
+ final List<ReactorStmtCtx<?, ?, ?>> effective) {
return effective instanceof ImmutableCollection ? effective : Collections.unmodifiableCollection(effective);
}
- private static List<StatementContextBase<?, ?, ?>> shrinkEffective(
- final List<StatementContextBase<?, ?, ?>> effective) {
+ private static List<ReactorStmtCtx<?, ?, ?>> shrinkEffective(final List<ReactorStmtCtx<?, ?, ?>> effective) {
return effective.isEmpty() ? ImmutableList.of() : effective;
}
public abstract void removeStatementFromEffectiveSubstatements(StatementDefinition statementDef);
- static final List<StatementContextBase<?, ?, ?>> removeStatementFromEffectiveSubstatements(
- final List<StatementContextBase<?, ?, ?>> effective, final StatementDefinition statementDef) {
+ static final List<ReactorStmtCtx<?, ?, ?>> removeStatementFromEffectiveSubstatements(
+ final List<ReactorStmtCtx<?, ?, ?>> effective, final StatementDefinition statementDef) {
if (effective.isEmpty()) {
return effective;
}
public abstract void removeStatementFromEffectiveSubstatements(StatementDefinition statementDef,
String statementArg);
- static final List<StatementContextBase<?, ?, ?>> removeStatementFromEffectiveSubstatements(
- final List<StatementContextBase<?, ?, ?>> effective, final StatementDefinition statementDef,
+ static final List<ReactorStmtCtx<?, ?, ?>> removeStatementFromEffectiveSubstatements(
+ final List<ReactorStmtCtx<?, ?, ?>> effective, final StatementDefinition statementDef,
final String statementArg) {
if (statementArg == null) {
return removeStatementFromEffectiveSubstatements(effective, statementDef);
return effective;
}
- final Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
+ final Iterator<ReactorStmtCtx<?, ?, ?>> iterator = effective.iterator();
while (iterator.hasNext()) {
final Mutable<?, ?, ?> next = iterator.next();
if (statementDef.equals(next.publicDefinition()) && statementArg.equals(next.rawArgument())) {
*/
public abstract void addEffectiveSubstatement(Mutable<?, ?, ?> substatement);
- final List<StatementContextBase<?, ?, ?>> addEffectiveSubstatement(
- final List<StatementContextBase<?, ?, ?>> effective, final Mutable<?, ?, ?> substatement) {
+ final List<ReactorStmtCtx<?, ?, ?>> addEffectiveSubstatement(final List<ReactorStmtCtx<?, ?, ?>> effective,
+ final Mutable<?, ?, ?> substatement) {
verifyStatement(substatement);
- final List<StatementContextBase<?, ?, ?>> resized = beforeAddEffectiveStatement(effective, 1);
- final StatementContextBase<?, ?, ?> stmt = (StatementContextBase<?, ?, ?>) substatement;
+ final List<ReactorStmtCtx<?, ?, ?>> resized = beforeAddEffectiveStatement(effective, 1);
+ final ReactorStmtCtx<?, ?, ?> stmt = (ReactorStmtCtx<?, ?, ?>) substatement;
final ModelProcessingPhase phase = completedPhase;
if (phase != null) {
ensureCompletedPhase(stmt, phase);
abstract void addEffectiveSubstatementsImpl(Collection<? extends Mutable<?, ?, ?>> statements);
- final List<StatementContextBase<?, ?, ?>> addEffectiveSubstatementsImpl(
- final List<StatementContextBase<?, ?, ?>> effective,
+ final List<ReactorStmtCtx<?, ?, ?>> addEffectiveSubstatementsImpl(final List<ReactorStmtCtx<?, ?, ?>> effective,
final Collection<? extends Mutable<?, ?, ?>> statements) {
- final List<StatementContextBase<?, ?, ?>> resized = beforeAddEffectiveStatement(effective, statements.size());
+ final List<ReactorStmtCtx<?, ?, ?>> resized = beforeAddEffectiveStatement(effective, statements.size());
final Collection<? extends StatementContextBase<?, ?, ?>> casted =
(Collection<? extends StatementContextBase<?, ?, ?>>) statements;
final ModelProcessingPhase phase = completedPhase;
return resized;
}
- abstract Iterable<StatementContextBase<?, ?, ?>> effectiveChildrenToComplete();
+ abstract Iterable<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete();
// exposed for InferredStatementContext only
final void ensureCompletedPhase(final Mutable<?, ?, ?> stmt) {
verifyStatement(stmt);
final ModelProcessingPhase phase = completedPhase;
if (phase != null) {
- ensureCompletedPhase((StatementContextBase<?, ?, ?>) stmt, phase);
+ ensureCompletedPhase((ReactorStmtCtx<?, ?, ?>) stmt, phase);
}
}
// 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) {
+ private static void ensureCompletedPhase(final ReactorStmtCtx<?, ?, ?> stmt, final ModelProcessingPhase phase) {
verify(stmt.tryToCompletePhase(phase), "Statement %s cannot complete phase %s", stmt, phase);
}
private static void verifyStatement(final Mutable<?, ?, ?> stmt) {
- verify(stmt instanceof StatementContextBase, "Unexpected statement %s", stmt);
+ verify(stmt instanceof ReactorStmtCtx, "Unexpected statement %s", stmt);
}
- private List<StatementContextBase<?, ?, ?>> beforeAddEffectiveStatement(
- final List<StatementContextBase<?, ?, ?>> effective, final int toAdd) {
+ private List<ReactorStmtCtx<?, ?, ?>> beforeAddEffectiveStatement(final List<ReactorStmtCtx<?, ?, ?>> effective,
+ final int toAdd) {
// We cannot allow statement to be further mutated
verify(completedPhase != ModelProcessingPhase.EFFECTIVE_MODEL, "Cannot modify finished statement at %s",
sourceReference());
return beforeAddEffectiveStatementUnsafe(effective, toAdd);
}
- final List<StatementContextBase<?, ?, ?>> beforeAddEffectiveStatementUnsafe(
- final List<StatementContextBase<?, ?, ?>> effective, final int toAdd) {
+ final List<ReactorStmtCtx<?, ?, ?>> beforeAddEffectiveStatementUnsafe(final List<ReactorStmtCtx<?, ?, ?>> effective,
+ final int toAdd) {
final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase();
checkState(inProgressPhase == ModelProcessingPhase.FULL_DECLARATION
|| inProgressPhase == ModelProcessingPhase.EFFECTIVE_MODEL,
abstract Stream<? extends StmtContext<?, ?, ?>> streamEffective();
- /**
- * 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(completedPhase) || doTryToCompletePhase(phase);
- }
-
- private boolean doTryToCompletePhase(final ModelProcessingPhase phase) {
+ @Override
+ final boolean doTryToCompletePhase(final ModelProcessingPhase phase) {
final boolean finished = phaseMutation.isEmpty() ? true : runMutations(phase);
if (completeChildren(phase) && finished) {
onPhaseCompleted(phase);
for (final StatementContextBase<?, ?, ?> child : mutableDeclaredSubstatements()) {
finished &= child.tryToCompletePhase(phase);
}
- for (final StatementContextBase<?, ?, ?> child : effectiveChildrenToComplete()) {
+ for (final ReactorStmtCtx<?, ?, ?> child : effectiveChildrenToComplete()) {
finished &= child.tryToCompletePhase(phase);
}
return finished;
}
@Override
- public final
StatementContextBase<A, D, E> replicaAsChildOf(final Mutable<?, ?, ?> parent) {
+ public final
ReactorStmtCtx<A, D, E> replicaAsChildOf(final Mutable<?, ?, ?> parent) {
checkArgument(parent instanceof StatementContextBase, "Unsupported parent %s", parent);
return replicaAsChildOf((StatementContextBase<?, ?, ?>) parent);
}
- final @NonNull
StatementContextBase<A, D, E> replicaAsChildOf(final StatementContextBase<?, ?, ?> stmt) {
+ final @NonNull
ReplicaStatementContext<A, D, E> replicaAsChildOf(final StatementContextBase<?, ?, ?> stmt) {
return new ReplicaStatementContext<>(stmt, this);
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action;
import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
public void onFullDefinitionDeclared(final Mutable<QName, ActionStatement, ActionEffectiveStatement> stmt) {
super.onFullDefinitionDeclared(stmt);
+ verify(stmt instanceof StatementContextBase);
if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
((StatementContextBase<?, ?, ?>) stmt).appendImplicitSubstatement(
InputStatementRFC7950Support.getInstance(), null);
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.yang.common.QName;
public final void onFullDefinitionDeclared(final Mutable<QName, RpcStatement, RpcEffectiveStatement> stmt) {
super.onFullDefinitionDeclared(stmt);
+ verify(stmt instanceof StatementContextBase);
if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
((StatementContextBase<?, ?, ?>) stmt).appendImplicitSubstatement(implictInput(), null);
}
Code Review / yangtools.git / commitdiff