import java.util.Objects;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nullable;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangVersion;
-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.StatementSource;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
private final QNameToStatementDefinitionMap qnameToStmtDefMap = new QNameToStatementDefinitionMap();
private final PrefixToModuleMap prefixToModuleMap = new PrefixToModuleMap();
private final BuildGlobalContext currentContext;
- private final StatementStreamSource source;
+
+ // Freed as soon as we complete ModelProcessingPhase.EFFECTIVE_MODEL
+ private StatementStreamSource source;
/*
* "imported" namespaces in this source -- this points to RootStatementContexts of
return inProgressPhase;
}
- Optional<StatementContextBase<?, ?, ?>> lookupDeclaredChild(final StatementContextBase<?, ?, ?> current,
- final int childId) {
- if (current == null) {
- return Optional.empty();
- }
-
- // Fast path: we are entering a statement which was emitted in previous phase
- StatementContextBase<?, ?, ?> existing = current.lookupSubstatement(childId);
- while (existing != null && StatementSource.CONTEXT == existing.getStatementSource()) {
- existing = existing.lookupSubstatement(childId);
- }
-
- return Optional.ofNullable(existing);
- }
-
- StatementContextBase<?, ?, ?> createDeclaredChild(final StatementContextBase<?, ?, ?> current, final int childId,
- final QName name, final String argument, final StatementSourceReference ref) {
+ AbstractResumedStatement<?, ?, ?> createDeclaredChild(final AbstractResumedStatement<?, ?, ?> current,
+ final int childId, final QName name, final String argument, final StatementSourceReference ref) {
StatementDefinitionContext<?, ?, ?> def = currentContext.getStatementDefinition(getRootVersion(), name);
if (def == null) {
def = currentContext.getModelDefinedStatementDefinition(name);
current);
}
- InferenceException.throwIfNull(def, ref, "Statement %s does not have type mapping defined.", name);
- if (def.hasArgument()) {
+ if (InferenceException.throwIfNull(def, ref, "Statement %s does not have type mapping defined.", name)
+ .getArgumentDefinition().isPresent()) {
SourceException.throwIfNull(argument, ref, "Statement %s requires an argument", name);
} else {
SourceException.throwIf(argument != null, ref, "Statement %s does not take argument", name);
return root != null ? root.getRootVersion() : RootStatementContext.DEFAULT_VERSION;
}
- DeclaredStatement<?> buildDeclared() {
- return root.buildDeclared();
- }
-
- EffectiveStatement<?, ?> buildEffective() {
- return root.buildEffective();
- }
-
void startPhase(final ModelProcessingPhase phase) {
- @Nullable final ModelProcessingPhase previousPhase = phase.getPreviousPhase();
+ final ModelProcessingPhase previousPhase = phase.getPreviousPhase();
verify(Objects.equals(previousPhase, finishedPhase),
"Phase sequencing violation: previous phase should be %s, source %s has %s", previousPhase, source,
finishedPhase);
return null;
}
- @Nullable
@Override
public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromLocalStorage(final Class<N> type) {
final Map<K, V> potentialLocal = getRoot().getAllFromLocalStorage(type);
}
@Override
- public NamespaceStorageNode getParentNamespaceStorage() {
+ public BuildGlobalContext getParentNamespaceStorage() {
return currentContext;
}
final Collection<ModifierImpl> currentPhaseModifiers = modifiers.get(phase);
boolean hasProgressed = tryToProgress(currentPhaseModifiers);
-
- checkNotNull(this.root, "Malformed source. Valid root element is missing.");
- final boolean phaseCompleted = root.tryToCompletePhase(phase);
+ final boolean phaseCompleted = requireNonNull(root, "Malformed source. Valid root element is missing.")
+ .tryToCompletePhase(phase);
hasProgressed |= tryToProgress(currentPhaseModifiers);
if (phaseCompleted && currentPhaseModifiers.isEmpty()) {
finishedPhase = phase;
LOG.debug("Source {} finished phase {}", source, phase);
+ if (phase == ModelProcessingPhase.EFFECTIVE_MODEL) {
+ // We have the effective model acquired, which is the final phase of source interaction.
+ LOG.trace("Releasing source {}", source);
+ source = null;
+ }
return PhaseCompletionProgress.FINISHED;
-
}
return hasProgressed ? PhaseCompletionProgress.PROGRESS : PhaseCompletionProgress.NO_PROGRESS;
}
private PrefixToModule preLinkagePrefixes() {
- final PrefixToModuleMap preLinkagePrefixes = new PrefixToModuleMap(true);
+ final PrefixToModuleMap preLinkagePrefixes = new PrefixToModuleMap();
final Map<String, URI> prefixToNamespaceMap = getAllFromLocalStorage(ImpPrefixToNamespace.class);
if (prefixToNamespaceMap == null) {
//:FIXME if it is a submodule without any import, the map is null. Handle also submodules and includes...
}
// We need to any and all extension statements which have been declared in the context
- final Map<QName, StatementSupport<?, ?, ?>> extensions = currentContext.getAllFromNamespace(
+ final Map<QName, StatementSupport<?, ?, ?>> extensions = currentContext.getNamespace(
StatementDefinitionNamespace.class);
if (extensions != null) {
extensions.forEach((qname, support) -> {