Package net.ssehub.easy.basics.modelManagement

Class DefaultImportResolver<M extends IModel>

  • 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 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

      • 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

      • 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