net.ssehub.easy.basics.modelManagement

Class DefaultImportResolver<M extends IModel>

java.lang.Object

net.ssehub.easy.basics.modelManagement.ImportResolver<M>

net.ssehub.easy.basics.modelManagement.DefaultImportResolver<M>

Type Parameters:

M - the specific model type

Direct Known Subclasses:

BuildLangImportResolver, DefaultImportResolver

public class DefaultImportResolver<M extends IModel>
extends ImportResolver<M>

A model imports resolver. Due to the instance data needed to perform cyclic model resolution, instances of this class are not reentrant during processing of one model and its imported models. Either instances are pooled or created individually per model translation.

Author:

Holger Eichelberger

Field Summary

Fields

Modifier and Type	Field and Description
private boolean	allowCycles
private ModelInfo<M>	conflictMarker
static boolean	IMPORT_WITH_VERSION Allows to switch easily to the primitive (non-version checking) variant.
private java.util.Map<ModelInfo<M>,M>	localModelOverride

Constructor Summary

Constructors

Constructor and Description
DefaultImportResolver() Creates a resolver instance which, by default, does not allow cycles in the model imports.
DefaultImportResolver(boolean allowCycles) Creates a resolver instance which may allow cycles.

Method Summary

Modifier and Type	Method and Description
private java.util.List<ModelImport<M>>	addConflict(java.util.List<ModelImport<M>> conflicts, ModelImport<M> conflict) Adds the given conflict conflicts to conflicts.
protected void	cannotResolveImport(ModelImport<M> imp, java.util.List<IMessage> messages, java.net.URI modelURI, IRestrictionEvaluationContext context) Is called if imp can finally not be resolved.
private void	checkImportCycles(M model, java.util.List<IMessage> messages, java.util.Set<M> done) Checks the import structure of model for cycles.
protected boolean	checkImported(ModelImport<M> imp, M model, java.util.List<IMessage> messages) Checks the imported interfaces for obvious import problems, such as importing models with interfaces as a whole.
void	clear() Clears this instance for reuse.
private ModelInfo<M>	determineMatching(ResolutionContext<M> context, java.util.List<VersionedModelInfos<M>> versions, IVersionRestriction restriction) Determine the model matching the import restrictions.
private void	handleImport(ResolutionContext<M> context, ModelImport<?> imp, java.util.List<ModelImport<M>> todo) Handles an import.
private void	handleImports(ResolutionContext<M> context, M model, java.util.List<ModelImport<M>> todo) Handles all imports for the given model.
private java.util.List<ModelImport<M>>	load(ResolutionContext<M> context, java.util.HashSet<M> done, ModelInfo<M> toLoad, java.util.List<IMessage> messages, ModelImport<M> imp, java.util.List<ModelImport<M>> conflicts) Loads the given model information, checks it for conflicts.
private java.util.List<ModelImport<M>>	resolve(ResolutionContext<M> context, java.util.HashSet<M> done, java.util.List<IMessage> messages) Resolves the import represented by context.
private java.util.List<ModelImport<M>>	resolve(ResolutionContext<M> context, java.util.HashSet<M> done, java.util.List<IMessage> messages, java.util.List<VersionedModelInfos<M>> versions, ModelImport<M> imp) Resolves the import / conflict represented by imp.
M	resolve(java.lang.String modelName, IVersionRestriction restrictions, java.net.URI baseUri, IModelRepository<M> repository, IRestrictionEvaluationContext evaluationContext) Resolves the denoted model considering the given restrictions.
java.util.List<IMessage>	resolveImports(M model, java.net.URI uri, java.util.List<ModelInfo<M>> inProgress, IModelRepository<M> repository, IRestrictionEvaluationContext evaluationContext) Resolves the imports of the given model and returns messages on failures.
private java.util.List<ModelImport<M>>	resolveImports(ResolutionContext<M> context, java.util.HashSet<M> done, java.util.List<IMessage> messages) Resolves the imports of the model in the given context and returns messages on failures.
private void	setUnresolved(M model, java.util.List<ModelImport<M>> conflicts) Sets the given model and its import recursively to unresolved.
private void	setUnresolved(M model, ModelImport<M> imp, java.util.List<ModelImport<M>> conflicts) Sets the given import in model and its imports recursively to unresolved.

Methods inherited from class net.ssehub.easy.basics.modelManagement.ImportResolver

addDeferredLoader, getProcessingListener, isTransitiveLoadingEnabled, notifyProcessing, setProcessingListener, setTransitiveLoading

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

IMPORT_WITH_VERSION

public static final boolean IMPORT_WITH_VERSION

Allows to switch easily to the primitive (non-version checking) variant.

See Also:

Constant Field Values

conflictMarker

private final ModelInfo<M extends IModel> conflictMarker

localModelOverride

private final java.util.Map<ModelInfo<M extends IModel>,M extends IModel> localModelOverride

allowCycles

private boolean allowCycles

Constructor Detail

DefaultImportResolver

public DefaultImportResolver()

Creates a resolver instance which, by default, does not allow cycles in the model imports.

DefaultImportResolver

public DefaultImportResolver(boolean allowCycles)

Creates a resolver instance which may allow cycles.

Parameters:

allowCycles - if true, allow and resolve cycles, if false emit an error

Method Detail

clear

public void clear()

Description copied from class: ImportResolver

Clears this instance for reuse.

Overrides:

clear in class ImportResolver<M extends IModel>

resolveImports

public java.util.List<IMessage> resolveImports(M model,
                                               java.net.URI uri,
                                               java.util.List<ModelInfo<M>> inProgress,
                                               IModelRepository<M> repository,
                                               IRestrictionEvaluationContext evaluationContext)

Description copied from class: ImportResolver

Resolves the imports of the given model and returns messages on failures. Exceptions might be appropriate here but the caller shall be able to decide how to handle the level of detail, i.e. whether the first message shall be emitted or all. May modify model as a side effect.

Specified by:

resolveImports in class ImportResolver<M extends IModel>

Parameters:

model - the model to be resolved

uri - the URI of the model to resolve (in order to find the closest model, may be null)

inProgress - the model information objects of the models currently being processed at once (may be null)

repository - the model repository

evaluationContext - the context for evaluating import restrictions (variable definitions... interpreted locally)

Returns:

messages which occur during resolution

checkImportCycles

private void checkImportCycles(M model,
                               java.util.List<IMessage> messages,
                               java.util.Set<M> done)

Checks the import structure of model for cycles.

Parameters:

model - the (root) model to be checked

messages - which occur during resolution, null or empty if none (modified as a side effect)

done - for detecting cyclic imports (modified as a side effect)

resolveImports

private java.util.List<ModelImport<M>> resolveImports(ResolutionContext<M> context,
                                                      java.util.HashSet<M> done,
                                                      java.util.List<IMessage> messages)

Resolves the imports of the model in the given context and returns messages on failures. Exceptions might be appropriate here but the caller shall be able to decide how to handle the level of detail, i.e. whether the first message shall be emitted or all.

Parameters:

context - the context of the models to be resolved

done - for detecting cyclic imports (modified as a side effect)

messages - which occur during resolution, null or empty if none (modified as a side effect)

Returns:

the conflicting model imports, null if there are none

setUnresolved

private void setUnresolved(M model,
                           java.util.List<ModelImport<M>> conflicts)

Sets the given model and its import recursively to unresolved.

Parameters:

model - the model to be set to unresolved

conflicts - the conflicts to unresolve exclusively, i.e., if not null other imports are not modified, otherwise all imports are set to unresolved

setUnresolved

private void setUnresolved(M model,
                           ModelImport<M> imp,
                           java.util.List<ModelImport<M>> conflicts)

Sets the given import in model and its imports recursively to unresolved.

Parameters:

model - the model containing imp

imp - the import to be set to unresolved

conflicts - the conflicts to unresolve exclusively, i.e., if not null other imports are not modified, otherwise all imports are set to unresolved

handleImports

private void handleImports(ResolutionContext<M> context,
                           M model,
                           java.util.List<ModelImport<M>> todo)

Handles all imports for the given model.

Parameters:

context - the resolution context

model - the model to handle the imports

todo - the imports to be handled in the calling step (may be null, then no todo list is built up)

handleImport

private void handleImport(ResolutionContext<M> context,
                          ModelImport<?> imp,
                          java.util.List<ModelImport<M>> todo)

Handles an import. If it denotes a conflict, it is added to the context, other to todo.

Parameters:

context - the context of the models to be resolved (may be modified as a side effect)

imp - the import to be handled

todo - the imports to be handled in the calling step (may be null, then no todo list is built up)

determineMatching

private ModelInfo<M> determineMatching(ResolutionContext<M> context,
                                       java.util.List<VersionedModelInfos<M>> versions,
                                       IVersionRestriction restriction)
                                throws ModelManagementException

Determine the model matching the import restrictions. If multiple matching models exist, return the model with the highest version number.

Parameters:

context - the import context

versions - the already known and matching model information objects

restriction - the version restriction (may be null)

Returns:

the matching model (null if there no model was found or conflictMarker if no matching model was determined due to conflicts on all possible candidates)

Throws:

ModelManagementException - in case of restriction evaluation problems

addConflict

private java.util.List<ModelImport<M>> addConflict(java.util.List<ModelImport<M>> conflicts,
                                                   ModelImport<M> conflict)

Adds the given conflict conflicts to conflicts. conflicts may be null and is created then lazily.

Parameters:

conflicts - the conflicts set to add the toAdd conflicts to

conflict - the conflicts to be added

Returns:

conflicts if not null, a new list otherwise

resolve

private java.util.List<ModelImport<M>> resolve(ResolutionContext<M> context,
                                               java.util.HashSet<M> done,
                                               java.util.List<IMessage> messages,
                                               java.util.List<VersionedModelInfos<M>> versions,
                                               ModelImport<M> imp)

Resolves the import / conflict represented by imp.

Parameters:

context - the import context

done - for detecting cyclic imports (modified as a side effect)

messages - which occur during resolution, null or empty if none (modified as a side effect)

versions - the already known and matching model information objects

imp - the import to be resolved

Returns:

the conflicting model imports, null if there are none

cannotResolveImport

protected void cannotResolveImport(ModelImport<M> imp,
                                   java.util.List<IMessage> messages,
                                   java.net.URI modelURI,
                                   IRestrictionEvaluationContext context)

Is called if imp can finally not be resolved.

Parameters:

imp - the import to be resolved

messages - which occur during resolution, null or empty if none (modified as a side effect)

modelURI - the URI of the model

context - the restriction evaluation context

load

private java.util.List<ModelImport<M>> load(ResolutionContext<M> context,
                                            java.util.HashSet<M> done,
                                            ModelInfo<M> toLoad,
                                            java.util.List<IMessage> messages,
                                            ModelImport<M> imp,
                                            java.util.List<ModelImport<M>> conflicts)

Loads the given model information, checks it for conflicts.

Parameters:

context - the import context

done - for detecting cyclic imports (modified as a side effect)

toLoad - the model to load

messages - which occur during resolution, null or empty if none (modified as a side effect)

imp - the import to be resolved

conflicts - the actual import conflicts (may be null if none were detected so far)

Returns:

the actual import conflicts

checkImported

protected boolean checkImported(ModelImport<M> imp,
                                M model,
                                java.util.List<IMessage> messages)

Checks the imported interfaces for obvious import problems, such as importing models with interfaces as a whole.

Parameters:

imp - the import to be resolved

model - the model which may resolve the import

messages - which occur during resolution, null or empty if none (modified as a side effect)

Returns:

true if the import is fine, true if problems were detected

resolve

public M resolve(java.lang.String modelName,
                 IVersionRestriction restrictions,
                 java.net.URI baseUri,
                 IModelRepository<M> repository,
                 IRestrictionEvaluationContext evaluationContext)
          throws ModelManagementException

Description copied from class: ImportResolver

Resolves the denoted model considering the given restrictions.

Specified by:

resolve in class ImportResolver<M extends IModel>

Parameters:

modelName - the name of the model

restrictions - the version restriction (may be null if there is none)

baseUri - the URI to start resolving from (may be the URI of a model)

repository - the model repository

evaluationContext - the context for evaluating import restrictions (variable definitions... interpreted locally)

Returns:

the resolved model

Throws:

ModelManagementException - in case of resolution failures

resolve

private java.util.List<ModelImport<M>> resolve(ResolutionContext<M> context,
                                               java.util.HashSet<M> done,
                                               java.util.List<IMessage> messages)

Resolves the import represented by context.

Parameters:

context - the context to resolve (including the import to resolve)

done - for detecting cyclic imports (modified as a side effect)

messages - which occur during resolution, null or empty if none (modified as a side effect)

Returns:

the conflicting model imports, null if there are none