Interface IComparisonParticipant

    • Method Detail

      • supports

        boolean supports​(ComparisonTreeNode node)
        Indicates whether the participant supports comparison and merging of the specified node.
        Parameters:
        node - the node, not null
        Returns:
        true if the participant supports comparison and merging, false otherwise
      • getModelPackage

        org.eclipse.emf.ecore.EPackage getModelPackage()
        Get EMF model package.
        Returns:
        the EMF model packge. Never code null.
      • compare

        List<Long> compare​(ComparisonTreeNode node,
                           ComparisonContext comparisonContext,
                           org.eclipse.core.runtime.IProgressMonitor monitor)
        Compares objects contained in the specified model node and returns a list of child nodes to be compared.
        Parameters:
        node - the node, not null
        comparisonContext - the comparison context, not null
        monitor - the progress monitor, can be null. The clients are not supposed to report work to the monitor, except for the top object matching phase
        Returns:
        a list of model node identifiers, never null
      • merge

        org.eclipse.core.runtime.IStatus merge​(ComparisonTreeNode node,
                                               MergeContext context,
                                               org.eclipse.core.runtime.IProgressMonitor monitor)
        Merges the differences in the specified node in the specified merge session. This may include deletion of the main object if the other object is absent, or, conversely, import ("copying") of the other object if the main object is absent.
        Parameters:
        node - the node, not null
        context - the current merge context, not null
        monitor - the progress monitor, not null
        Returns:
        the result of the merge operation
      • createMergeContext

        MergeContext createMergeContext​(ComparisonTreeNode node,
                                        IMergeSession mergeSession,
                                        ComparisonContext comparisonContext)
        Creates merge context for an upcoming merge operation.
        Parameters:
        node - the node, not null
        mergeSession - the current merge session, not null
        comparisonContext - the comparison context, not null
        Returns:
      • onChildrenMerged

        void onChildrenMerged​(ComparisonTreeNode topNode,
                              MergeContext context)
        Called when the child nodes of the specified top node have been merged.
        Parameters:
        topNode - the top node, not null
        context - Current merge operation context, not null
      • getForcedDDRebuildScope

        Map<String,​IBmObject> getForcedDDRebuildScope​(BmTopComparisonNode topNode,
                                                            MergeContext context)
        In case if the merge process changes the top object it should supply information about affected DDs.
        Parameters:
        topNode - The top node of the comparison model representing the merged object, never null
        context - Current merge operation context, not null
        Returns:
        The map of the affected DD segments and corresponding objects, could be null or empty
      • getSerializedMergeSettings

        MergeSettingsContainer getSerializedMergeSettings​(IComparisonSession session,
                                                          ComparisonTreeNode node)
        Returns serialized merge settings
        Parameters:
        session - the comparison session
        node - the node to get merge settings for, not null
        Returns:
        serialized merge settings
      • getPotentialCorrespondingNodes

        List<ComparisonTreeNode> getPotentialCorrespondingNodes​(ComparisonTreeNode node,
                                                                ComparisonSide sourceSide)
        Returns a list of candidate nodes for setting as corresponding to the specified node.
        Parameters:
        node - the comparison result node to find potential correspondences for, not null
        sourceSide - the source side of the correspondence, not null
        Returns:
        a list of comparison result nodes or null if this kind of nodes is not supported by this participant
      • breakCorrespondence

        boolean breakCorrespondence​(ComparisonContext comparisonContext,
                                    ComparisonTreeNode node)
        Asks the participant to break correspondence represented by the specified model node. The participant may refuse to break correspondence if it does not support this kind of node.
        Parameters:
        comparisonContext - the comparison context, not null
        node - the node with the correspondence to break, not null
        Returns:
        true if the participant supported the operation, and false otherwise
      • updateComparison

        boolean updateComparison​(ComparisonContext comparisonContext,
                                 ComparisonTreeNode node,
                                 List<Long> newNodeIds)
        Updates comparison for the given result node. Participants could introduce their own specific logic for managing internal states on comparison update.
        Parameters:
        comparisonContext - the comparison context, not null
        node - the node to update comparison for, not null
        newNodeIds - the list of created new node Ids to fill, not null
        Returns:
        true if the participant supported the operation, and false otherwise
      • addNewTopObjectToComparison

        ComparisonTreeNode addNewTopObjectToComparison​(IComparisonSession comparisonSession,
                                                       String mainSymlink,
                                                       org.eclipse.emf.ecore.EClass eClass)
        Adds a new node to the comparison for the top object. Participants could introduce their own specific logic for managing internal states on comparison update.
        Parameters:
        comparisonSession - the comparison session hosting the model, not null
        mainSymlink - the symlink for the top object to add, not null
        eClass - of the object ot add, not null
        Returns:
        The created result node for the object if supports. null otherwise.
      • combineOneSideNodes

        boolean combineOneSideNodes​(ComparisonContext comparisonContext,
                                    ComparisonTreeNode mainNode,
                                    ComparisonTreeNode otherNode,
                                    List<Long> newNodeIds)
        Asks the participant to combine the specified two one-side nodes. The participant may refuse to do it if it does not support this kind of nodes. The participant fills array of new node Ids created while combining the specified nodes. These node Ids must be scheduled for comparison in the external code.
        Parameters:
        comparisonContext - the comparison context, not null
        mainNode - the one-side MAIN node to be combined, not null
        otherNode - the one-side OTHER node to be combined, not null
        newNodeIds - the list of new node Ids to fill, not null
        Returns:
        true if the participant supported the operation, and false otherwise
      • ableToBreakCorrespondence

        boolean ableToBreakCorrespondence​(ComparisonTreeNode node)
        Checks if this participant is able to break a correspondence stored in the specified node.
        Parameters:
        node - the node to check if its correspondence can be broken by this participant, not null
        Returns:
        true if this participant is able to break the correspondence, and false otherwise
      • retrieveComparedObjects

        IComparedObjects<?> retrieveComparedObjects​(ComparisonContext comparisonContext,
                                                    ComparisonTreeNode node)
        Returns a compared EObjects triple for the specified model node.
        Parameters:
        comparisonContext - the comparison context, not null
        node - the model node, cannot be null
        Returns:
        the compared objects triple, never null
      • prepareRenameOperations

        List<IRenameOnMergeOperation> prepareRenameOperations​(IMergeSession mergeSession,
                                                              ComparisonContext context)
        Gets a list of rename operations prepared by this participant.
        Parameters:
        mergeSession - the merge session, not null
        context - the comparison context, not null
        Returns:
        the list of rename operations, never null
      • validateMerge

        void validateMerge​(IMergeSession mergeSession,
                           ComparisonContext comparisonContext,
                           ComparisonTreeNode node,
                           List<MergeValidationProblem> validationProblems)
        Validates the process of merge of the specified model node.
        Parameters:
        mergeSession - the merge session, not null
        comparisonContext - the comparison context, not null
        node - the model node
        validationProblems - the list of collected validation problems to add new problem to
      • clear

        void clear()
        Clears the participant caches.
      • adopt

        ComparisonTreeNode adopt​(IComparisonSession session,
                                 ExternalPropertyComparisonNode node)
        Converts, if possible, the given external property node into a node supported by the participant instance.
        Parameters:
        session - the comparison session, not null
        node - the node to adopt
        Returns:
        the node adopted or null if adopting is not possible
      • supportsPrioritizedMerging

        boolean supportsPrioritizedMerging​(ComparisonTreeNode node,
                                           IComparisonSession session)
        Tells whether the given node supports prioritized merging.
        Parameters:
        node - the node to check, cannot be null
        session - the comparison session, cannot be null
        Returns:
        true if the node supports prioritized merging, false otherwise
      • supportsCustomMerging

        boolean supportsCustomMerging​(ComparisonTreeNode node,
                                      IComparisonSession session)
        Tells whether the given node supports custom merging.
        Parameters:
        node - the node to check, cannot be null
        session - the comparison session, cannot be null
        Returns:
        true if the node supports custom merging, false otherwise
      • supportsMergingUsingExternalTool

        boolean supportsMergingUsingExternalTool​(ComparisonTreeNode node,
                                                 IComparisonSession session)
        Tells whether the given node supports merging using external tool.
        Parameters:
        node - the comparison node to check, cannot be null
        session - the comparison session, cannot be null
        Returns:
        true if the node supports merging using external tool, false otherwise
      • breakMainSideCorrespondence

        boolean breakMainSideCorrespondence​(IComparisonSession comparisonSession,
                                            ComparisonTreeNode node)
        Asks the participant to break main side correspondence represented by the specified model node. The participant may refuse to break main side correspondence if it does not support this kind of node.
        Parameters:
        comparisonSession - the comparison session hosting the model, can not be null
        node - the node with the correspondence to break, can not be null
        Returns:
        true if the participant supported the operation and false otherwise
      • isExcludedFromComparison

        boolean isExcludedFromComparison​(org.eclipse.emf.ecore.EStructuralFeature feature,
                                         AbstractComparedEmfObjects<?> comparedContextObjects,
                                         IComparisonSession session)
        Checks whether the feature must be excluded from the comparison.
        Parameters:
        feature - the feature to check, cannot be null
        comparedContextObjects - the triple of compared objects, cannot be null
        session - the comparison session, cannot be null
        Returns:
        true if the feature must be excluded, false otherwise
      • getDefaultMergeRule

        MergeRule getDefaultMergeRule​(ComparisonTreeNode node,
                                      IComparisonSession session)
        Returns the default merge rule for the given node.
        Parameters:
        node - the node to get default merge rule for, can not be null
        session - the comparison session, can not be null
        Returns:
        the default merge rule or null if it wasn't specified
      • adoptMainSideFeature

        org.eclipse.emf.ecore.EStructuralFeature adoptMainSideFeature​(org.eclipse.emf.ecore.EStructuralFeature mainSideFeature,
                                                                      IComparisonSession session)
        Converts, if possible, the main side feature into a other supported by the other side object.
        Parameters:
        mainSideFeature - the main side feature to convert, cannot be null
        session - the comparison session, cannot be null
        Returns:
        the converted feature applicable for other side object or null
      • getDefaultMustBeMerged

        Boolean getDefaultMustBeMerged​(ComparisonTreeNode node,
                                       IComparisonSession session)
        Returns the default must be merged value for the given node.
        Parameters:
        node - the node to get default must be merged value for, can not be null
        session - the comparison session, can not be null
        Returns:
        the default must be merged value or null if it wasn't specified
      • restoreCustomSettings

        void restoreCustomSettings​(ComparisonTreeNode node,
                                   MergeSettingsContainer container,
                                   IComparisonSession session)
        Restores custom settings for the specified node from the given merge settings container.
        Parameters:
        node - the comparison node to restore custom settings for, cannot be null
        container - the container of serialized settings, cannot be null
        session - the comparison session, cannot be null
      • isCandidateForPotentialMergeProblems

        boolean isCandidateForPotentialMergeProblems​(ComparisonTreeNode node,
                                                     IComparisonSession session)
        Tells whether the given node may break the configuration if it is merged.
        Parameters:
        node - the node to check, cannot be null
        session - the comparison session, cannot be null
        Returns:
        true if the node may break the configuration, false otherwise
      • getPotentialMergeProblemsDescriptions

        List<PotentialMergeProblemDescription> getPotentialMergeProblemsDescriptions​(ComparisonTreeNode node,
                                                                                     ComparisonContext comparisonContext)
        Returns human-readable descriptions of potential merge problems if the the specified node is merged.
        Parameters:
        node - the node to get merge problems descriptions for, cannot be null
        comparisonContext - the comparison context, cannot be null
        Returns:
        the list of descriptions, never null, can be empty if the node doesn't bring any merge problems
      • mergeUsingExternalTool

        ExternalMergeToolResult mergeUsingExternalTool​(ComparisonTreeNode node,
                                                       ComparisonContext comparisonContext,
                                                       org.eclipse.core.runtime.IProgressMonitor monitor)
        Merges nodes using an external tool that are supported by this participant.
        Parameters:
        node - the comparison node, cannot be null
        comparisonContext - the comparison context, cannot be null
        monitor - the progress monitor, cannot be null
        Returns:
        the external merge tool result or null if no nodes were merged