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.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.SupportedFeaturesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.NamespaceBehaviourWithListeners.KeyedValueAddedListener;
private Multimap<ModelProcessingPhase, OnPhaseFinished> phaseListeners = ImmutableMultimap.of();
private Multimap<ModelProcessingPhase, ContextMutation> phaseMutation = ImmutableMultimap.of();
- private List<Mutable<?, ?, ?>> effective = ImmutableList.of();
+ private List<StatementContextBase<?, ?, ?>> effective = ImmutableList.of();
private List<StmtContext<?, ?, ?>> effectOfStatement = ImmutableList.of();
private @Nullable ModelProcessingPhase completedPhase;
return;
}
- final Iterator<Mutable<?, ?, ?>> iterator = effective.iterator();
+ final Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
while (iterator.hasNext()) {
final Mutable<?, ?, ?> next = iterator.next();
if (statementDef.equals(next.getPublicDefinition()) && statementArg.equals(next.rawStatementArgument())) {
* if statement parameter is null
*/
public void addEffectiveSubstatement(final Mutable<?, ?, ?> substatement) {
+ verifyStatement(substatement);
beforeAddEffectiveStatement(1);
- effective.add(substatement);
+
+ final StatementContextBase<?, ?, ?> stmt = (StatementContextBase<?, ?, ?>) substatement;
+ final ModelProcessingPhase phase = completedPhase;
+ if (phase != null) {
+ ensureCompletedPhase(stmt, phase);
+ }
+ effective.add(stmt);
}
/**
* if statement parameter is null
*/
public void addEffectiveSubstatements(final Collection<? extends Mutable<?, ?, ?>> statements) {
- if (statements.isEmpty()) {
- return;
+ if (!statements.isEmpty()) {
+ statements.forEach(StatementContextBase::verifyStatement);
+ beforeAddEffectiveStatement(statements.size());
+
+ final Collection<? extends StatementContextBase<?, ?, ?>> casted =
+ (Collection<? extends StatementContextBase<?, ?, ?>>) statements;
+ final ModelProcessingPhase phase = completedPhase;
+ if (phase != null) {
+ for (StatementContextBase<?, ?, ?> stmt : casted) {
+ ensureCompletedPhase(stmt, phase);
+ }
+ }
+
+ effective.addAll(casted);
}
+ }
+
+ // 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);
+ }
- statements.forEach(Objects::requireNonNull);
- beforeAddEffectiveStatement(statements.size());
- effective.addAll(statements);
+ private static void verifyStatement(final Mutable<?, ?, ?> stmt) {
+ verify(stmt instanceof StatementContextBase, "Unexpected statement %s", stmt);
}
private void beforeAddEffectiveStatement(final int toAdd) {
+ // We cannot allow statement to be further mutated
+ final StatementSourceReference ref = getStatementSourceReference();
+ verify(completedPhase != ModelProcessingPhase.EFFECTIVE_MODEL, "Cannot modify finished statement at %s", ref);
+
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());
+ "Effective statement cannot be added in declared phase at: %s", ref);
if (effective.isEmpty()) {
effective = new ArrayList<>(toAdd);
@Override
public E buildEffective() {
- final E existing = effectiveInstance;
- return existing != null ? existing : (effectiveInstance = definition.getFactory().createEffective(this));
+ 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) {
-
- boolean finished = true;
- final Collection<ContextMutation> openMutations = phaseMutation.get(phase);
- if (!openMutations.isEmpty()) {
- final Iterator<ContextMutation> it = openMutations.iterator();
- while (it.hasNext()) {
- final ContextMutation current = it.next();
- if (current.isFinished()) {
- it.remove();
- } else {
- finished = false;
- }
- }
+ final boolean tryToCompletePhase(final ModelProcessingPhase phase) {
+ return phase.isCompletedBy(completedPhase) || doTryToCompletePhase(phase);
+ }
- if (openMutations.isEmpty()) {
- phaseMutation.removeAll(phase);
- if (phaseMutation.isEmpty()) {
- phaseMutation = ImmutableMultimap.of();
- }
- }
+ 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 Mutable<?, ?, ?> child : effective) {
- if (child instanceof StatementContextBase) {
- finished &= ((StatementContextBase<?, ?, ?>) child).tryToCompletePhase(phase);
+ for (final StatementContextBase<?, ?, ?> child : effective) {
+ finished &= child.tryToCompletePhase(phase);
+ }
+ return finished;
+ }
+
+ private boolean runMutations(final ModelProcessingPhase phase) {
+ final Collection<ContextMutation> openMutations = phaseMutation.get(phase);
+ return openMutations.isEmpty() ? true : runMutations(phase, openMutations);
+ }
+
+ private boolean runMutations(final ModelProcessingPhase phase, final Collection<ContextMutation> openMutations) {
+ boolean finished = true;
+ final Iterator<ContextMutation> it = openMutations.iterator();
+ while (it.hasNext()) {
+ final ContextMutation current = it.next();
+ if (current.isFinished()) {
+ it.remove();
+ } else {
+ finished = false;
}
}
- if (finished) {
- onPhaseCompleted(phase);
- return true;
+ if (openMutations.isEmpty()) {
+ phaseMutation.removeAll(phase);
+ if (phaseMutation.isEmpty()) {
+ phaseMutation = ImmutableMultimap.of();
+ }
}
- return false;
+ return finished;
}
/**
completedPhase = phase;
final Collection<OnPhaseFinished> listeners = phaseListeners.get(phase);
- if (listeners.isEmpty()) {
- return;
+ if (!listeners.isEmpty()) {
+ runPhaseListeners(phase, listeners);
}
+ }
+ private void runPhaseListeners(final ModelProcessingPhase phase, final Collection<OnPhaseFinished> listeners) {
final Iterator<OnPhaseFinished> listener = listeners.iterator();
while (listener.hasNext()) {
final OnPhaseFinished next = listener.next();
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);
}
return false;
}
- // Exists only to support SubstatementContext/InferredStatementContext
+ // Exists only to support {SubstatementContext,InferredStatementContext}.getSchemaPath()
+ @Deprecated
final @NonNull Optional<SchemaPath> substatementGetSchemaPath() {
SchemaPath local = schemaPath;
if (local == null) {
synchronized (this) {
local = schemaPath;
if (local == null) {
- local = createSchemaPath(coerceParentContext());
- schemaPath = local;
+ schemaPath = local = createSchemaPath(coerceParentContext());
}
}
}
return Optional.ofNullable(local);
}
+ @Deprecated
private SchemaPath createSchemaPath(final Mutable<?, ?, ?> parent) {
final Optional<SchemaPath> maybeParentPath = parent.getSchemaPath();
verify(maybeParentPath.isPresent(), "Parent %s does not have a SchemaPath", parent);
final Object argument = getStatementArgument();
if (argument instanceof QName) {
final QName qname = (QName) argument;
- if (StmtContextUtils.producesDeclared(this, UsesStatement.class)) {
+ if (producesDeclared(UsesStatement.class)) {
return maybeParentPath.orElse(null);
}
return parentPath.createChild(qname);
}
if (argument instanceof SchemaNodeIdentifier
- && (StmtContextUtils.producesDeclared(this, AugmentStatement.class)
- || StmtContextUtils.producesDeclared(this, RefineStatement.class)
- || StmtContextUtils.producesDeclared(this, DeviationStatement.class))) {
+ && (producesDeclared(AugmentStatement.class) || producesDeclared(RefineStatement.class)
+ || producesDeclared(DeviationStatement.class))) {
- return parentPath.createChild(((SchemaNodeIdentifier) argument).getPathFromRoot());
+ return parentPath.createChild(((SchemaNodeIdentifier) argument).getNodeIdentifiers());
}
// FIXME: this does not look right