# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary
AbstractAccessorFactory: An abstract implementation of `IAccessorFactory`.
AbstractChangeFactory: Factory of difference extensions.
AbstractCompareECrossReferencerAdapter: Abstract class that redefines `AbstractCompareECrossReferencerAdapter.handleContainment(org.eclipse.emf.common.notify.Notification)` to mimic `EContentAdapter` behavior.
AbstractCompareHandler
AbstractComparisonScope: This implementation of `IComparisonScope` can be sub-classed in order to avoid re-implementing some of the methods imposed by this interface.
AbstractConfigurationUI: Abstract composite that is used to configure an item.
AbstractConflictSearch<T extends Diff>: Class in charge of finding conflicting diffs for a given diff of type T.
AbstractContextTester: An abstract implementation of `IContextTester` that provides convenience methods for retrieving values from the context map.
AbstractCopyCommand: This command can be used to copy a number of diffs (or a single one) in a given direction.
AbstractDifferenceFilter: An abstract filter implementation.
AbstractDifferenceGroupProvider: Abstract implementation of `IDifferenceGroupProvider`.
AbstractEMFCompareEditorInput: Abstract subclass of `CompareEditorInput` to be use to open CompareEditor with results of EMF Compare.
AbstractItemDescriptor<T>: Abstract class for an `IItemDescriptor`.
AbstractLogicalModelViewHandler: Abstract implementation of the handling of editors' activations, for the Logical Model View.
AbstractMergeContainedAction: Abstract `MergeAction` for merging all diffs contained in the selection.
AbstractMerger: Abstract implementation of an `IMerger`.
AbstractMergeRunnable: Provides inheritable default behavior for the merge runnables.
AbstractMergeViewer: An abstract implementation of `IMergeViewer`.
AbstractModelResolver: This can be subclassed instead of `IModelResolver` to avoid reimplementing common extension-related code.
AbstractMonitoredProxyCreationListener: Asbtract super-class of `IProxyCreationListener`s to use for computing the logical model.
AbstractRegistryEventListener: Abstract utility class to listen to the `IExtensionRegistry`.
AbstractRegistryEventListener.Action: Enumeration that says if the `IConfigurationElement` is to be added or removed from the `IExtensionRegistry`.
AbstractResolution: Abstract super-class of resolving computations.
AbstractResourceSetHooks: Abstract implementation of `IResourceSetHook`.
AbstractStructuralFeatureAccessor: An abstract implementation of `IStructuralFeatureAccessor`.
AbstractStructuredMergeViewer: A specific `AbstractMergeViewer` for the EMF Compare Editor.
AbstractStructuredViewerWrapper<C extends org.eclipse.swt.widgets.Control,​V extends org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.IWrappableStructuredViewer>
AbstractStructuredViewerWrapper.ControlAndViewer<C extends org.eclipse.swt.widgets.Control,​V extends org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.IWrappableStructuredViewer>
AbstractTableOrTreeItemWrapper: A wrapper of Table Item or Tree Item.
AbstractTableOrTreeMergeViewer: An abstract specialization of `AbstractStructuredMergeViewer` for Tables or Trees.
AbstractTableOrTreeMergeViewer.ElementComparer: A specific implementation of `IElementComparer` that compare EMF Compare Viewer Items.
AbstractTableOrTreeMergeViewer.MesureItemListener: This will be used in order to resize the table items to an even height.
AbstractTreeContentMergeViewer: Specialized `ContentMergeViewer` that uses `TreeViewer` to display left, right and ancestor `EObject`.
AbstractTypedElementAdapter: An abstract implementation of `ITypedElement`.
AbstractWeightProvider: Abstract implementation which is parameterized to set weights based on features, to ignore features and consider "name" features as more important.
AccessBasedLRUCache<K,​V>: A Map acting like a LRU cache which will evict elements which have not been accessed in a while.
AccessorAdapter
AccessorFactoryExtensionRegistryListener: The default concrete implementation of `AbstractRegistryEventListener`.
AccessorFactoryRegistryImpl: The default implementation of `IAccessorFactory.Registry`.
AdapterFactoriesPreferencePage: Preferences page used to enable/disable adapter factories that have been contributed to EMF Compare.
AdapterFactoryChange
AdapterFactoryUtil: Deprecated. Use `AdapterFactoryItemDelegator` instead.
AdditiveConflictMerger: This specific implementation of `AbstractMerger` will be used to merge conflicts in an additive merge context.
AdditiveMergeCriterion: Merge Criterion that indicates we want to perform an 'Additive' merge.
AdditiveReferenceChangeMerger: This specific implementation of `AbstractMerger` will be used to merge reference changes in an additive merge context.
AdditiveResourceAttachmentChangeMerger: This specific implementation of `AbstractMerger` will be used to merge resource attachment changes in an additive merge context.
AdditiveResourceMappingMerger
AttributeChange: A representation of the model object 'Attribute Change'.
AttributeChangeConflictSearch: Search conflicts for `AttributeChange`s.
AttributeChangeConflictSearch.Add: Search conflicts for `AttributeChange` of kind `DifferenceKind.ADD`.
AttributeChangeConflictSearch.Change: Search conflicts for `AttributeChange` of kind `DifferenceKind.CHANGE`.
AttributeChangeConflictSearch.Delete: Search conflicts for `AttributeChange` of kind `DifferenceKind.DELETE`.
AttributeChangeConflictSearch.Move: Search conflicts for `AttributeChange` of kind `DifferenceKind.MOVE`.
AttributeChangeImpl: An implementation of the model object 'Attribute Change'.
AttributeChangeItemProvider: This is the item provider adapter for a `AttributeChange` object.
AttributeChangeItemProviderSpec: Specialized `AttributeChangeItemProvider` returning nice output for `AttributeChangeItemProviderSpec.getText(Object)` and `AttributeChangeItemProviderSpec.getImage(Object)`.
AttributeChangeMerger: This specific implementation of `AbstractMerger` will be used to merge attribute changes.
AttributeChangeSpec: This specialization of the `AttributeChangeImpl` class allows us to define the derived features and operations implementations.
BasicDifferenceGroupImpl: This implementation of a `IDifferenceGroup` uses a predicate to filter the whole list of differences.
BasicPostProcessorDescriptorImpl: A simple implementation of `IPostProcessor.Descriptor` that will delegate its method implementation to values given to its constructor.
BatchMerger: This implementation of an `IBatchMerger` leaves some choice to the client as to what should be merged.
ByResourceGroupProvider: This implementation of a `IDifferenceGroupProvider` will be used to group the differences by their Resource.
ByResourceGroupProvider.ResourceGroup: Specialized `BasicDifferenceGroupImpl` for Resources.
ByTypeIndex: An implementation of EObjectIndex which segregates given EObjects using their type and then delegate to other indexes.
CachingDiffRelationshipComputer: A computer implementation to cache the relationship of diffs.
CachingDistance: This class wraps a DistanceFunction and cache its result.
CachingImplicitDependencies: An implementation of the `IImplicitDependencies` that delegates the respective dependency calculation to a given object and caches the results to increase performance.
CascadingDifferencesFilter: A filter used by default that filters out cascading differences (differences located under a Match that is either ADDed or DELETEd on the diff's side).
CollapseAllModelAction
ColorChangeEvent: Event to notify a color change.
CommandStackEvent: An event that can be passed to `CommandStackListener.commandStackChanged(EventObject)`.
CommandStackEvent.Operation: An event type.
CompareAccessorMergeViewerItemProvider: Implementation of `IMergeViewerItemProvider` which extracts the `IMergeViewerItem`s from `ICompareAccessor`s.
CompareAdapterFactory: The Adapter Factory for the model.
CompareColorImpl: Default implementation that use a cache to store created Color and that is listening to a preference store for color configuration.
CompareCommandStack: A simple `ICompareCommandStack` that delegate execution to another command stack but keep informations about execution to properly reply to `ICompareCommandStack` protocol.
CompareCommandStack.CompareSideCommandStack: Simple data structure acting like a command stack but without any execution capability.
CompareEditingDomainChange
CompareEvent<T>
CompareFactory: The Factory for the model.
CompareFactoryImpl: An implementation of the model Factory.
CompareHandlerService
CompareInDialog
CompareInNewEditor
CompareInputAdapter
CompareItemProviderAdapterFactory: This is the factory that is used to provide the interfaces needed to support Viewers.
CompareItemProviderAdapterFactorySpec: Specialized `CompareItemProviderAdapterFactory` returning ItemProviderAdapter with nice `IItemLabelProvider.getText(Object)` and `IItemLabelProvider.getImage(Object)`.
ComparePackage: The Package for the model.
ComparePackage.Literals: Defines literals for the meta objects that represent each class, each feature of each class, each enum, and each data type
ComparePackageImpl: An implementation of the model Package.
CompareSwitch<T>: The Switch for the model's inheritance hierarchy.
CompareToolBar
Comparison: A representation of the model object 'Comparison'.
ComparisonAccessorFactory: A specific `IAccessorFactory` for `Comparison` objects.
ComparisonAndScopeChange
ComparisonCanceledException: Exception used to manage cancellation of comparison operations.
ComparisonEditorInput
ComparisonImpl: An implementation of the model object 'Comparison'.
ComparisonIndex: Index of diffs in a comparison.
ComparisonItemProvider: This is the item provider adapter for a `Comparison` object.
ComparisonItemProviderSpec: Specialized `ComparisonItemProvider` returning nice output for `ComparisonItemProvider.getText(Object)` and `ComparisonItemProvider.getImage(Object)`.
ComparisonScopeBuilder: This will be used by EMF Compare in order to construct its comparison scope given a "starting point".
ComparisonScopeEditorInput: CompareEditorInput that will compute the result of the comparison of the given scope with the given comparator.
ComparisonScopeInput
ComparisonSpec: This specialization of the `ComparisonImpl` class allows us to define the derived features and operations implementations.
ComparisonUtil: This utility class provides common methods for navigation over and querying of the Comparison model.
ComposedStyledString: Composed styled string implementation backed by an `ArrayList`.
CompoundModelMinimizer: This class encapsulates a list of model minimizers and propagates any calls to each element in the list.
ComputeDiffsToMerge: This class computes the diffs to merge for a given diff in the correct order, taking into account the merger's indications about required and consequent diffs.
ConfigurationUIRegistryEventListener: Registry event listener used for `IConfiguratorUIRegistry`
Conflict: A representation of the model object 'Conflict'.
ConflictImpl: An implementation of the model object 'Conflict'.
ConflictItemProvider: This is the item provider adapter for a `Conflict` object.
ConflictItemProviderSpec: Specialized `ConflictItemProvider` returning nice output for `ConflictItemProviderSpec.getText(Object)` and `ConflictItemProviderSpec.getImage(Object)`.
ConflictKind: A representation of the literals of the enumeration 'Conflict Kind', and utility methods for working with them.
ConflictMerger: This specific implementation of `AbstractMerger` will be used to merge real conflicts.
ConflictNode: This class is wrapper for TreeNode used to represent a conflict TreeNode.
ConflictNodeBuilder
ConflictSearchFactory: Factory for ConflictSearch classes.
ConflictSpec: This specialization of the `ConflictImpl` class allows us to define the derived features and operations implementations.
ContainmentRefChangeConflictSearch: Search conflicts for containment `ReferenceChange`s.
ContainmentRefChangeConflictSearch.Add: Search conflicts for containment `ReferenceChange` of kind `DifferenceKind.ADD`.
ContainmentRefChangeConflictSearch.Change: Search conflicts for containment `ReferenceChange` of kind `DifferenceKind.CHANGE`.
ContainmentRefChangeConflictSearch.Delete: Search conflicts for containment `ReferenceChange` of kind `DifferenceKind.DELETE`.
ContainmentRefChangeConflictSearch.Move: Search conflicts for containment `ReferenceChange` of kind `DifferenceKind.MOVE`.
ContainmentReferenceChangeAccessorFactory: A specific `IAccessorFactory` for containment `ReferenceChange` objects.
ContainmentReferenceChangeAccessorImpl: A specific `AbstractStructuralFeatureAccessor` for containment `ReferenceChange` objects.
ContentMergeViewerCustomizationDescriptor<T>: The generic descriptor for content merge viewer customizations.
ContentMergeViewerCustomizationRegistry: The registry responsible for managing the content merge viewer customizations.
ContentMergeViewerCustomizationRegistryListener: The listener responsible for handling registration events regarding content merge viewer customizations.
ContextUtil: Utility class for evaluating context testers in adapter factory descriptors.
CopyCommand: Deprecated. Use `MergeCommand` instead.
CrossReferenceResolutionScope: Defines the scope for the resolution of a file's logical model.
DataHolder<T>: POJO used to hold data from preference page.
DefaultComparisonFactory: A default implementation of `IComparisonFactory` that creates a new `Comparison` through the `default CompareFactory`.
DefaultComparisonScope: This is the default implementation of an `IComparisonScope`.
DefaultConflictDetector: The conflict detector is in charge of refining the Comparison model with all detected Conflict between its differences.
DefaultDiffEngine: The diff engine is in charge of actually computing the differences between the objects mapped by a `Match` object.
DefaultEqualityHelperFactory: Default implementation of `IEqualityHelperFactory`.
DefaultEquiEngine: The requirements engine is in charge of actually computing the equivalences between the differences.
DefaultGroupProvider: This implementation of a `IDifferenceGroupProvider` will be used as the default group provider.
DefaultImplicitDependencies: Default implementation of `IImplicitDependencies`, which uses the extensions collected by the registry of the modelDependencyProvider extension point.
DefaultMatchEngine: The Match engine orchestrates the matching process : it takes an `scope` as input, iterates over its `left`, `right` and `origin` roots and delegates to `IResourceMatcher`s and `IEObjectMatcher`s in order to create the result `Comparison` model for this scope.
DefaultMatchEngineConfiguatorUIFactory: IConfiguratorUIFactory for `DefaultRCPMatchEngineFactory`
DefaultMatchEngineConfiguratorUI: `AbstractConfigurationUI` for `DefaultRCPMatchEngineFactory`.
DefaultRCPMatchEngineFactory: Implementation of `IMatchEngine.Factory` for the `DefaultMatchEngine` that can be configured.
DefaultReqEngine: The requirements engine is in charge of actually computing the requirements between the differences.
DefaultResolutionContext: Default implementation of `IResolutionContext`.
DefaultWeightProvider: The default implementation of `WeightProvider` applicable to all objects.
DelegatingCommandStack: Abstract implementation that forward method calls to a `delegatating` `CommandStack`.
DelegatingMerger: Wrapper of mergers that makes sure that a given `IMergeCriterion` is passed to the wrapped merger before calling its merge method, and that the former value of criterion used by the wrapped merger is restored afterwards.
DelegatingTreeMergeViewerItemContentProvider: This implementation of `ITreeContentProvider` delegates to the `IMergeViewerItemProvider`s and `IMergeViewerItemContentProvider`s registered via the content merge viewer customization extension point.
DelegatingURIConverter: This implementation of an `URI Converter` will delegate all calls to another.
DependencyData
DependencyFoundEvent<T>: Event indicating a dependency between two resources has been found.
DependencyGraphUpdater<T>: This class's responsibility is to maintain the state of its graph when notified that a new model resource or a new dependency have been found.
DependencyProviderDescriptor: This class is used for information flow between `ModelDependencyProviderRegistryListener` and `ModelDependencyProviderRegistry` and managing the creation of `IDependencyProvider` instances.
DescriptorRegistryEventListener<T>: Base class for Descriptor Registry.
DiagnosticSupport: Encapsulated a diagnostic to hide multi-threaded details.
Diff: A representation of the model object 'Diff'.
diff_match_patch: Class containing the diff, match and patch methods.
diff_match_patch.Diff: Class representing one diff operation.
diff_match_patch.LinesToCharsResult: Internal class for returning results from diff_linesToChars().
diff_match_patch.Operation: The data structure representing a diff is a Linked list of Diff objects: {Diff(Operation.DELETE, "Hello"), Diff(Operation.INSERT, "Goodbye"), Diff(Operation.EQUAL, " world.")} which means: delete "Hello", add "Goodbye" and keep " world."
diff_match_patch.Patch: Class representing one patch operation.
DiffBuilder: This default implementation of an `IDiffProcessor` will build the necessary differences and attach them to the appropriate `Match`.
DiffCrossReferencer: This implementation of an `ECrossReferenceAdapter` will allow us to only attach ourselves to the Diff elements.
DifferenceFilterChange: The default implementation of `IDifferenceFilterChange`.
DifferenceFilterExtensionRegistryListener: Utility class to listen to the `IDifferenceFilter.Registry`.
DifferenceFilterManager: Manager of filters.
DifferenceFilterRegistryImpl: The default implementation of the `IDifferenceFilter.Registry`.
DifferenceGroupDescriptorWrapper: Implementation of `IDifferenceGroupProvider.Descriptor`.
DifferenceGroupExtenderRegistryImpl: The default implementation of the `IDifferenceGroupExtender.Registry`.
DifferenceGroupExtenderRegistryListener: Utility class to listen to the `IDifferenceGroupProvider.Descriptor.Registry` .
DifferenceGroupManager: This manager can be used to modify EMF Compare UI behavior regarding groups.
DifferenceGroupProviderChange: The default implementation of `IDifferenceGroupProviderChange`.
DifferenceGroupProviderExtensionRegistryListener: Utility class to listen to the `IDifferenceGroupProvider.Descriptor.Registry`.
DifferenceGroupRegistryImpl: Implementation of the `IDifferenceGroupProvider.Descriptor.Registry`.
DifferenceKind: A representation of the literals of the enumeration 'Difference Kind', and utility methods for working with them.
DifferenceSource: A representation of the literals of the enumeration 'Difference Source', and utility methods for working with them.
DifferenceState: A representation of the literals of the enumeration 'Difference State', and utility methods for working with them.
DiffImpl: An implementation of the model object 'Diff'.
DiffItemProvider: This is the item provider adapter for a `Diff` object.
DiffNode: This class is wrapper for TreeNode used to represent a diff TreeNode.
DiffRelationshipComputer: A computer implementation to calculate the relationship of differences in EMF Compare.
DiffRelationshipComputerChange: A change for `IDiffRelationshipComputer`.
DiffSpec: This specialization of the `DiffImpl` class allows us to define the derived features and operations implementations.
DiffTreeIterator: A custom iterator that will walk a Match->submatch tree, and allow iteration over the Diffs of these Matches.
DiffUtil: This utility class will be used to provide similarity implementations.
DiffUtil: Deprecated. Not intendended to be used by clients
DisposableResourceSet: A `ResourceSet` that offers a dispose method.
DropDownMergeMenuAction: Action that manages the dropdown menu that allows to show the consequences of an accept or a reject.
DualCompareCommandStack: `ICompareCommandStack` implementation that will delegates to two given command stacks; one for each side of the comparison.
DynamicObject: Utility class to access (R/W) field in super class hierarchy.
EcoreWeightProvider: The implementation of `WeightProvider` applicable to all ecore objects.
EditionDistance: This distance function implementation will actually compare the given EObject.
EditionDistance.Builder: Builder class to configure an EditionDistance instance.
EditorPreferencePage: Preference page for UI settings related to the comparison editor.
EMFComparatorChange
EMFCompare: This class serves as the main entry point of a comparison.
EMFCompare.Builder: A Builder pattern to instantiate EMFCompare objects.
EMFCompareBuilderConfigurator: Engine provider.
EMFCompareChangeRecorder: This custom implementation of a change recorder will avoid copying the internal lists every time they're needed as they can grow to very large sizes along with the size of the compared models.
EMFCompareColor
EMFCompareConfiguration
EMFCompareConstants
EMFCompareContentMergeViewer
EMFCompareContentMergeViewerResourceBundle: This resource bundle wraps the resource bundle of an EMF Compare content merge viewer to default to the resource bundle of the Eclipse Compare TextMergeViewer for any non-defined keys.
EMFCompareCopier: This defines the semantics of an EObject copy in the case of EMF Compare.
EMFCompareDeferredTreeContentManager: A wrapper interface for `DeferredTreeContentManager` which enables EMFCompare to switch between its own and the default platform implementation.
EMFCompareDeferredTreeContentManagerImpl: The default implementation of `EMFCompareDeferredTreeContentManager` forwards to `DeferredTreeContentManager`.
EMFCompareDeferredTreeContentManagerProvider: Provider Service for `EMFCompareDeferredTreeContentManager`s.
EMFCompareDeferredTreeContentManagerUtil: Util Class for handling `EMFCompareDeferredTreeContentManagerProvider` service.
EMFCompareDiffTreeRuler: A specific canvas that must be presented next to a TreeViewer.
EMFCompareEditingDomain: Default implementation that use a change recorder in the background to record the changes made by executed commands.
EMFCompareEditMessages: Utility class to access externalized Strings for this bundle.
EMFCompareEditorLMVHandler: Handle, for the Logical Model View, the EMF Compare editor activations.
EMFCompareEditPlugin: This is the central singleton for the Compare edit plugin.
EMFCompareEditPlugin.Implementation: The actual implementation of the Eclipse Plugin.
EMFCompareIDEPlugin: The activator class controls the plug-in life cycle.
EMFCompareIDEUIMessages: Utility class to access externalized Strings for this bundle.
EMFCompareIDEUIPlugin: The activator class, controls the plug-in life cycle.
EMFCompareJavaPredicates: This class will provide a number of Predicates that can be used to retrieve particular `Diff`s from an iterable.
EMFCompareLogger: Mimics the Log4J 1 logger interface but sends all logging to the Eclipse log.
EMFCompareLogger.Level
EMFCompareMessages: Utility class to access externalized Strings for EMF Compare's core.
EMFComparePredicates: Deprecated. this class provides Guava predicates.
EMFComparePreferencePage: Global preference page for EMF Compare
EMFComparePreferences: Preferences constants and utilities for the EMF Compare RCP plug-in.
EMFComparePrettyPrinter: This class exposes methods to serialize a "human-readable" form of the comparison model onto a given stream.
EMFCompareRCPMessages: Utility class to access externalized Strings for EMF Compare's ide integration.
EMFCompareRCPPlugin: This is the central singleton for the EMF Compare RCP plugin.
EMFCompareRCPUIMessages: Utility class to access externalized Strings for EMF Compare's rcp ui integration.
EMFCompareRCPUIPlugin: The activator class controls the plug-in life cycle.
EMFCompareStructureMergeViewer: Implementation of `AbstractStructuredViewerWrapper`.
EMFCompareStructureMergeViewerContentProvider: Specialized AdapterFactoryContentProvider for the emf compare structure merge viewer.
EMFCompareStructureMergeViewerContentProvider.CallbackType: Enum used for better readability of the method `EMFCompareStructureMergeViewerContentProvider.runWhenReady(CallbackType, Runnable)`.
EMFCompareStructureMergeViewerCreator
EMFCompareStructureMergeViewerLabelProvider: A specialized `AdapterFactoryLabelProvider.FontAndColorProvider` for the structure merge viewer.
EMFCompareTextMergeViewer
EMFCompareTextMergeViewer.EditCommand: A compound command that updates the value of a feature associated with a diff and rejects the diff itself.
EMFCompareTextMergeViewerContentProvider
EMFCompareTextMergeViewerCreator
EMFCompareUIPreferences: Set of preferences affecting the behavior of the EMF Compare user interface.
EMFCompareUIPreferencesInitializer: This will be used to initialize all of our UI preferences to their default.
EMFComparisonSourceActionHandler: Handles the comparison between selections adapting to `IEMFComparisonSource`s.
EMFLogicalModelAdapterFactory: Provides adapters for the `EMFModelProvider`.
EMFModelProvider: This implementation of a `ModelProvider` will be used to provide the logical model associated with EMF models.
EMFModelResourceTester: Property tester specifying whether an `IFile` should be treated as EMF model resource and hence should be handled by EMF Compare.
EMFReflectiveEditorLMVHandler: Handle, for the Logical Model View, the EMF Reflective editors' activations.
EMFResourceMapping: This will be used to represent an EMF resource's mapping.
EMFResourceMappingMerger: A customized merger for the `EMFResourceMapping`s.
EMFResourceMappingMerger.ResourceAdditionAndDeletionTracker
EMFSynchronizationCompareAdapter: Allows us to provide comparison support for the EMF model provider.
EmptyComparisonScope: This implementation of a comparison scope can be supplied to EMF Compare if there was an error beyond repair during the creation of the scope.
EmptyDifferenceGroupProvider: An empty difference group provider.
EnginesPreferencePage: Preference page for engines preferences
EObjectIndex: An EObjectIndex has for responsability to store/remove EObjects and return the closest EObject from another one (each one being registered with a different Side.
EObjectIndex.Side: An enumeration used in the API to specify sides.
EObjectUtil: Static utilities to create human readable EObject.toString() methods.
EqualityHelper: EMF Compare needs its own rules for "equality", which are based on similarity instead of strict equality.
EqualityHelperExtensionProvider: Compute specific matching rules.
EqualityHelperExtensionProvider.Descriptor: Wrapper describing the given equality helper extension provider.
EqualityHelperExtensionProvider.Descriptor.Registry: Registry of equality helper extension provider descriptors.
EqualityHelperExtensionProvider.SpecificMatch: Enumeration used to return the result of a specific matching.
EqualityHelperExtensionProviderDescriptorRCPImpl: Describes an extension as contributed to the "org.eclipse.emf.compare.rcp.equalityHelperExtensionProvider" extension point.
EqualityHelperExtensionProviderDescriptorRegistryImpl: This will contain all of the EMF Compare equality helper extension provider descriptors.
EqualityHelperExtensionProviderDescriptorRegistryListener: Listener for contributions to the match engine extension.
Equivalence: A representation of the model object 'Equivalence'.
EquivalenceImpl: An implementation of the model object 'Equivalence'.
EquivalenceItemProvider: This is the item provider adapter for a `Equivalence` object.
EUriFragmentFunction: A function computing an URI Fragment.
ExceptionUtil: This provides access to commonly used functions which need to handle exceptions.
ExpandAllModelAction
ExpandAllModelAction.TimeboxedExpandItemsRunnable
ExplorersViewSelectionLMVHandler: Handle, for the Logical Model View, the item(s) selected in Project Explorer View or Package Explorer View.
ExtendedAdapterFactoryItemDelegator: An item provider adapter factory delegator that supports our custom item provider interfaces: `IItemStyledLabelProvider`, `IItemDescriptionProvider` and `ISemanticObjectLabelProvider` .
ExtendedItemProviderDecorator: And extended `ItemProviderDecorator` that provides an `OverlayImageProvider` and and `ExtendedAdapterFactoryItemDelegator`.
FeatureFilter: `FeatureFilter`s will be used by the default implementation of a diff engine in order to determine which features it is to check for differences.
FeatureFilterAdapter: This will be used to attach the FeatureFilter to its comparison so that it can be used after the diff process.
FeatureMapChange: A representation of the model object 'Feature Map Change'.
FeatureMapChangeConflictSearch: Search conflicts for `FeatureMapChange`s.
FeatureMapChangeConflictSearch.Add: Search conflicts for `FeatureMapChange` of kind `DifferenceKind.ADD`.
FeatureMapChangeConflictSearch.Change: Search conflicts for `ReferenceChange` of kind `DifferenceKind.CHANGE`.
FeatureMapChangeConflictSearch.Delete: Search conflicts for `FeatureMapChange` of kind `DifferenceKind.DELETE`.
FeatureMapChangeConflictSearch.Move: Search conflicts for `FeatureMapChange` of kind `DifferenceKind.MOVE`.
FeatureMapChangeImpl: An implementation of the model object 'Feature Map Change'.
FeatureMapChangeItemProvider: This is the item provider adapter for a `FeatureMapChange` object.
FeatureMapChangeItemProviderSpec: Specialized `FeatureMapChangeItemProvider` returning nice output for `FeatureMapChangeItemProviderSpec.getText(Object)` and `FeatureMapChangeItemProviderSpec.getImage(Object)`.
FeatureMapChangeMerger: This specific implementation of `AbstractMerger` will be used to merge attribute changes.
FeatureMapChangeMoveAccessorFactory: A specific `IAccessorFactory` for FeatureMapChanges of kind DifferenceKind.MOVE (represent an entry that moved from map to another).
FeatureMapChangeSpec: This specialization of the `FeatureMapChangeImpl` class allows us to define the derived features and operations implementations.
FeatureMapKeyChangeAccessorFactory: A specific `IAccessorFactory` for FeatureMapChanges of kind DifferenceKind.CHANGE (represent a value that changed his key).
FeatureMapKeyChangeAccessorImpl: A specific `AbstractStructuralFeatureAccessor` for FeatureMapChanges of kind DifferenceKind.CHANGE (represent a value that changed his key).
FileRevisionStorageProvider: Allows access to the underlying IFileRevision's storage.
FilterAction: These will be the actual actions displayed in the filter menu.
FilterActionMenu: This will be displayed atop the structure viewer as the "filters" menu.
FilterComparisonScope: This implementation of an `IComparisonScope` can be provided specific filters to filter out parts of the Notifiers' content lists.
FilteredIterator<E>: A wrapper for a `TreeIterator` that only returns nodes that satisfy a predicate and skips all others and their descendants.
FiltersPreferencePage: Preference page for `IDifferenceFilter`.
ForwardingCompareConfiguration
ForwardingCompareConfiguration.MirroredPropertyChangeListener: A property change listener that listens specifically for the property indicating that compare configuration's {@link ForwardingCompareConfiguration#isMirrored()isMirrored} value has changed.
ForwardingCompareInput
ForwardingCompareInput.ForwardingTypedElement
ForwardingCompareInputAdapter
ForwardingItemProvider: Deprecated. Use `IItemProviderDecorator` and `DecoratorAdapterFactory` instead.
ForwardingXMLDefaultHandler: This implementation of an `XMLDefaultHandler` will forward all calls to its delegate.
ForwardingXMLHandler: This implementation of an `XMLHandler` will forward all calls to its delegate.
ForwardingXMLHelper: This implementation of an `XMLHelper` will forward all calls to its delegate.
Graph<E>: This structure will be used to maintain a undirected graph of elements.
GroupAction: This action will allow us to group differences by their kind.
GroupActionMenu: This menu will display actions that will allow the user to group differences together.
GroupItemProviderAdapter: An specific `ItemProviderAdapter` for groups.
GroupsInteractiveContent: Interactive content used for `IDifferenceGroupProvider` preferences.
GroupsPreferencePage: Preference page for group providers.
IAccessorFactory: A factory of `ITypedElement`s.
IAccessorFactory.Registry: The registry of `IAccessorFactory`.
IAdapterFactoryChange
IAdditiveResourceMappingMerger: The use case for this feature is really specific : it is used when a user use git to create branch representing feature releases.
IBatchMerger: This interface describes the general contract of what EMF Compare expects in order to "copy all" diffs from a given Comparison or list.
IChangeFactory: An `IChangeFactory` is a factory capable to create an `extension` from a `Diff` if and only if this factory can `handle` the given `Diff`.
IColorChangeEvent: A event notifying the bus that some color have change their value.
ICompareAccessor: An ICompareAccessor is an `ITypedElement` used to present an input object in the EMF Compare UI.
ICompareColor: Implementation of this interface will return color of decorator of `difference`.
ICompareColor.Provider: A provider of ICompareColor.
ICompareCommandStack: An extended `command stack` that knows about each save state of the comparison.
ICompareCopyCommand: Interface of compare copy (merge) command.
ICompareEditingDomain: Something like EMF's `EditingDomain` but dedicated to the handling of comparison merging and undoing / redoing those merge.
ICompareEditingDomainChange
ICompareEvent: Marker interface for all events related to EMF Compare.
IComparisonAndScopeChange
IComparisonFactory: A factory for `Comparison`.
IComparisonProvider: Specific comparison input that can be used to directly provide a pre-computed Comparison to the EMF Compare UI.
IComparisonScope: This class defines the expected contract of EMF Compare scopes.
IComparisonScope2: The scope of a model comparison.
IComputation<T>: Encapsulates the logic of a computation that can be identified by a key.
IConfigurationUIFactory: Factory for `AbstractConfigurationUI`.
IConflictDetector: This class defines the general contract of a Conflict detector.
IContextTester: A tester to evaluate whether a given context matches certain criteria.
IDeactivableDiffFilter: A `IDifferenceFilter` that can be fully deactivated in the preferences.
IdenticalResourceMinimizer: Instances of this class will be used by EMF Compare to minimize the scope to parts of a logical model that can be considered valid candidates for a difference.
IdentifierEObjectMatcher: This implementation of an `IEObjectMatcher` will create `Match`es based on the input EObjects identifiers (either XMI:ID or attribute ID) alone.
IdentifierEObjectMatcher.DefaultIDFunction: The default function used to retrieve IDs from EObject.
IDependencyProvider: Contract for clients of the org.eclipse.emf.ecompare.ide.ui.modelDependencies extension point.
IDiagnosable: An element that can hold a diagnostic.
IDiffEngine: This class defines the general contract of a Differencing engine.
IDifferenceFilter: Instances of this class will be used by EMF Compare in order to provide difference filter facilities to the structural differences view.
IDifferenceFilter.Registry: A registry of `IDifferenceFilter`.
IDifferenceFilterChange: Stores selected and unselected filters, and a predicate that aggregates the selected state predicates of selected filters and the unselected state predicates of unselected filters.
IDifferenceGroup: This interface represents an EMF Compare "group" of differences that can be displayed in the structural differences viewer of the UI.
IDifferenceGroupExtender: Instances of this class will be used by EMF Compare in order to extend the children of TreeNodes containing in the structure merge viewer.
IDifferenceGroupExtender.Registry: A registry of `IDifferenceGroupExtender`.
IDifferenceGroupProvider: Instances of this class will be used by EMF Compare in order to provide difference grouping facilities to the structural differences view.
IDifferenceGroupProvider.ComparisonType: Type of comparison a `IDifferenceGroupProvider` can handle.
IDifferenceGroupProvider.Descriptor: A descriptor that can create adifference group provider.
IDifferenceGroupProvider.Descriptor.Registry: A registry of `IDifferenceGroupProvider`.
IDifferenceGroupProvider2: Extended interface of `IDifferenceGroupProvider` that gives information on the building status of its groups.
IDifferenceGroupProviderChange: Stores selected `IDifferenceGroupProvider`.
IDiffProcessor: An `IDiffProcessor` is meant to be used in order to react to the detection of differences by the diff engine.
IDiffRelationshipComputer: A computer to retrieve the dependent diffs, resulting merges and resulting rejections for a diff.
IDiffRelationshipComputerChange: Event indicating a change in `IDiffRelationshipComputer`.
IEMFComparatorChange
IEMFCompareBuilderConfigurator: Engine provider for EMF Compare.
IEMFCompareConfiguration
IEMFComparisonSource: This adapter is used by EMFCompare to check if a compare button especially for EMFCompare should be added.
IEObjectMatcher: An `IEObjectMatcher` will be used by the default implementation of the `DefaultMatchEngine` in order to determine the mappings between three lists of EObjects coming from the left, right and origin sides.
IEqualityHelper: Use to compare objects by the `IMatchEngine`.
IEqualityHelperFactory: A factory that instantiate IEqualityHelper.
IEquiEngine: .
IGraph<E>: Interface of a directed graph.
IGraphConsumer: Graph consumer, that maintains the state of a graph created by a third party.
IGraphView<E>: Read-only view of a `Graph`.
IImplicitDependencies: This interface describes the contract of providing the set of files that must be used "together with" a given file, whatever the desired semantics of "together with" is.
IItemDescriptionProvider: This is the interface implemented to provide a description for an item.
IItemDescriptor<T>: An item descriptor.
IItemRegistry<T>: Item registry.
IItemStyledLabelProvider: This is the interface implemented to provide a styled label for an item.
ILoadOnDemandPolicy: A policy that can be asked to if it is authorizing resource to be loaded on demand.
ILoadOnDemandPolicy.Registry: A registry of policy.
ILogicalModelViewHandler: Handle, for the Logical Model View, the editors activations and the selections of items.
IMatchEngine: This class defines the general contract of a Matching engine.
IMatchEngine.Factory: Wrapper describing the given match engine.
IMatchEngine.Factory.Registry: A registry of `IMatchEngine.Factory`.
IMergeAllNonConflictingRunnable: The basic contract for a "merge all non-conflicting" differences.
IMergeCriterion: Criterion for describing a merge operation.
IMergeCriterionAware: This interface is used to select mergers according to some criterion.
IMergeData: Interface implemented by `MergeDataImpl`.
IMergeOptionAware: Handles a list of merge options.
IMergePreviewModeChange
IMerger: Mergers are used by EMF Compare to merge specific differences from one side to the other.
IMerger.Registry: This will hold all registered mergers.
IMerger.Registry2: Registry that can provide its mergers sorted by rank descending.
IMerger.RegistryImpl: A default implementation of an `IMerger.Registry`.
IMerger2: This adds the ability for `mergers` to define their own sub-set of "required" differences.
IMergeResolutionListener: Provides an interface for listening to the events of a successful merge resolution.
IMergeRunnable: Interface for executing merge commands from the `ICompareEditingDomain`.
IMergeViewer: A specific `IInputSelectionProvider` for EMF Compare.
IMergeViewer.MergeViewerSide: An enum that represents the side of the viewer and provides utilty methods to manage sides.
IMergeViewerItem: An IMergeViewerItem associate a Diff and its left side, right side and ancestor side values.
IMergeViewerItem.Container: Deprecated. IMergeViewerItem.Container is no longer needed since its functionality is now provided by `IMergeViewerItemContentProvider`.
IMergeViewerItemContentProvider: Interface for specialized `tree content providers` for the comparison content merge viewer.
IMergeViewerItemProvider: The contract for providers responsible for determining root elements in merge viewers.
IMergeViewerItemProviderConfiguration: The configuration used by `IMergeViewerItemContentProvider`s.
IModelInclusionTester: A model tester specifies whether an `IFile` shall be considered as EMF Model or not.
IModelMinimizer: This can be used in order to tell EMF Compare how to minimize the logical model to a reduced set of resources.
IModelMinimizer.Registry: A registry for model minimizers.
IModelResolver: This can be used in order to tell EMF Compare how the logical model of a given file can be resolved in its entirety.
IModelUpdateStrategy: A strategy for updating the model with changes made from within a content merge viewer.
IModelUpdateStrategyProvider: Provider for `model update strategies`.
INamespaceDeclarationListener: The listener interface for receiving namespace declaration events from the XML parsers.
InteractiveUIContent: A User interface that holds a viewer and satellites elements.
InteractiveUIContent.InteractiveUIBuilder<T>: Builder for an Interactive UI.
IOptionalProvider: A contract for a provider which can indicate whether it wants to handle a certain object.
IPostProcessor: Implementations of this interface can be used in order to tell EMF Compare how to make post treatments at each step of the comparison.
IPostProcessor.Descriptor: Wrapper describing the given post processor.
IPostProcessor.Descriptor.Registry<K>: Registry of post processor.
IProxyCreationListener: Describes the contract for a proxy creation listener as can be notifier from this pool's created parsers.
IReqEngine: This class defines the general contract of a Requirements engine.
IResolutionContext: A resolution context provides the different elements that can be involved in a comparison taking logical models into account.
IResourceContentsAccessor: A specific `ICompareAccessor` for resource contents.
IResourceDependencyLocalResolver: A resource dependency provider is in charge of providing the dependencies of resources (local or remote resources, remote meaning hosted in git for instance).
IResourceDependencyProvider: A resource dependency provider is in charge of providing the dependencies of resources (local or remote resources, remote meaning hosted in git for instance).
IResourceDependencyRemoteResolver: A resource dependency provider is in charge of providing the dependencies of resources (local or remote resources, remote meaning hosted in git for instance).
IResourceMatcher: An `IResourceMatcher` will be used to match two or three `Resource`s together; depending on whether we are doing a two or three way comparison.
IResourceMatchingStrategy: A `StrategyResourceMatcher` will be used to match two or three `Resource`s together; depending on whether we are doing a two or three way comparison.
IResourceSetHook: Interface used to hook some behavior into the `ResourceSet` used by EMF Compare when using logical model.
ISemanticObjectLabelProvider: Provider of labels for semantic objects.
IStoragePathAdapterProvider: This class is a wrapper used to create different kind of StoragePathAdapter depending on the needs.
IStoragePathProvider: Some implementations of IStorage provide a plain erroneous `path`.
IStoragePathProvider2: .
IStorageProvider: Used by the logical model to wrap types that can provide IStorages.
IStorageProviderAccessor: This will be used by URI Converters in order to retrieve the storages for the files it seeks.
IStorageProviderAccessor.DiffSide: Used by the resolution process to determine the side of the revision to fetch.
IStreamContentAccessor: An `IStreamContentAccessor` object represents a set of bytes which can be accessed by means of a stream.
IStructuralFeatureAccessor: A specific `ICompareAccessor` for structural features.
IStyledString: Utility class that mimics the JFace's StyledString.
IStyledString.IComposedStyledString: An iterable of `IStyledString`.
IStyledString.Style: A style class for `IStyledString`.
IStyledString.Style.BorderStyle: The possible styles of the border.
IStyledString.Style.StyleBuilder: A `IStyledString.Style` builder.
IStyledString.Style.UnderLineStyle: The possible styles of the underline.
ISubscriberProvider: Contract for clients of the org.eclipse.emf.ecompare.ide.ui.subscriberProvider extension point.
ItemDescriptorLabelProvider: Label provider for `IItemDescriptor`.
ItemRegistry<T>: Registry holding `IItemDescriptor`.
ItemUtil: Util class for item.
ITooltipLabelProvider: Provider of tooltips.
ITypedElement: Interface for getting the name, image, and type for an object.
JFaceUtil
JobProgressInfoComposite
JobProgressMonitorWrapper
KindGroupProvider: This implementation of a `IDifferenceGroupProvider` will be used to group the differences by their `kind` : additions, deletions, changes and moves.
LabelContentViewer: A dummy viewer that displays a single label.
LabeledViewerCreator: Creates an empty viewer with a single centered label which say to wait for the comparison to finish or there is no selected item if the comparison is finished.
LazyItemDescriptor<T>: Descriptor for an item.
LineBasedDiff: Extends `diff_match_patch` with a line-based diffing capability.
LoadOnDemandPolicyRegistryImpl: A default implementation that uses a map internally.
LoadOnDemandPolicyRegistryListener: A listener for load on demand policy extension point.
LocalModelResolution: This will be called by Team in order to determine whether a given file can be compared alone, or if it needs to be compared along with others (and, thus, compared from the synchronize view).
LocalModelsResolution: Called by EMF Compare in order to resolve the logical models corresponding to the given IResources.
LocalMonitoredProxyCreationListener: Implementation of `IProxyCreationListener` for local resolutions.
LocationMatchingStrategy: This implementation of a matching strategy will only use String equality on the resource URIs to try and find resource mappings.
LoggingPreferencePage: Preference page used to configure logging in EMFCompare.
LogicalModelView: A simple view displaying the resources of a logical model.
LogicalModelView.Presentation: Presentation mode of the viewer.
LogicalModelViewContentProvider: ContentProvider for the logical model view.
LogicalModelViewHandlerDescriptor: Descriptor of an `ILogicalModelViewHandler`.
LogicalModelViewHandlerRegistry: This registry implements its own strategy to define the "best" Logical Model Editors Handler to use.
LogicalModelViewHandlerRegistryListener: This listener will react to changes against our logical model editor handler extension point, allowing us to be in sync with plugin activation and deactivation.
LogicalModelViewHandlerUtil: Util methods, for the Logical Model View handlers.
LogicalModelViewLabelProvider: LabelProvider for the logical model view.
ManyStructuralFeatureAccessorFactory: A specific `IAccessorFactory` for multi-valued structural feature objects.
ManyStructuralFeatureAccessorImpl: A specific `AbstractStructuralFeatureAccessor` for multi-valued structural feature objects.
Match: A representation of the model object 'Match'.
MatchAccessor: A specific `ICompareAccessor` for `Match` objects.
MatchAccessorFactory: A specific `IAccessorFactory` for `Match` objects.
MatchAheadOfTime: Implementators of this interface might provide elements to be matched "ahead of time".
MatchBasedConflictDetector: This conflict detector searches for conflicting `Diff`s in the same `Match` as the current `Diff`, as well as among `ReferenceChange`s that reference the same `EObject` as the current `Diff`, if it is a `ReferenceChange`.
MatchCrossReferencer: This implementation of an `ECrossReferenceAdapter` will allow us to only attach ourselves to the Match elements.
MatchEngineFactoryDescriptor: Descriptor for `IMatchEngine.Factory`.
MatchEngineFactoryImpl: The default implementation of the `IMatchEngine.Factory.Registry`.
MatchEngineFactoryRegistryImpl: The default implementation of the `IMatchEngine.Factory.Registry`.
MatchEngineFactoryRegistryListener: Listener for contributions to the match engine extension.
MatchEngineFactoryRegistryWrapper: MatchEnginefactoryRegistry that wrap an IItemRegistry<IMatchEngine.Factory>.
MatchImpl: An implementation of the model object 'Match'.
MatchItemProvider: This is the item provider adapter for a `Match` object.
MatchItemProviderSpec: Specialized `MatchItemProvider` returning nice output for `MatchItemProviderSpec.getText(Object)` and `MatchItemProviderSpec.getImage(Object)`.
MatchNode: This class is wrapper for TreeNode used to represent a match TreeNode.
MatchOfContainmentReferenceChangeAdapter: Specific `Adapter` to `Match`es that are related to containment `ReferenceChange`s (that are placed in their parent `Match`).
MatchOfContainmentReferenceChangeProcessor: Process a comparison to detect `Match`es related to containment ReferenceChange.
MatchResource: A representation of the model object 'Match Resource'.
MatchResourceAccessorFactory: A specific `IAccessorFactory` for `MatchResource` objects.
MatchResourceImpl: An implementation of the model object 'Match Resource'.
MatchResourceItemProvider: This is the item provider adapter for a `MatchResource` object.
MatchResourceItemProviderSpec: Specialized `MatchResourceItemProvider` returning nice output for `MatchResourceItemProviderSpec.getText(Object)` and `MatchResourceItemProviderSpec.getImage(Object)`.
MatchResourceNode: This class is wrapper for TreeNode used to represent a match resource TreeNode.
MatchSpec: This specialization of the `MatchImpl` class allows us to define the derived features and operations implementations.
MatchUtil: This utility class holds methods that will be used by the diff and merge processes.
MergeAction: Abstract Action that manages a merge of a difference in case of both sides of the comparison are editable.
MergeAllNonConflictingAction: Action that manages a merge of a all non-conflicting difference.
MergeAllNonConflictingCommand: A merge command that merges all non-conflicting differences of the given comparison in either direction.
MergeBlockedByConflictException: Exception that indicates that a merge cannot be performed because it would lead to involuntarily resolving a conflict.
MergeCommand: A merge command that delegates it `MergeCommand.doExecute()` to the `IMergeRunnable.merge(List, boolean, IMerger.Registry)` method.
MergeConflictingRunnable: Implements the "merge all contained conflicting" action.
MergeContainedAction: This action will merge all differences contained in the selection, regardless of conflicts or originating side.
MergeContainedConflictingAction: Action that manages a merge of a contained conflicting differences in case the selection is a resource match or a model element match.
MergeContainedNonConflictingAction: Action that manages a merge of a contained non-conflicting difference in case the selection is a resource match or a model element match.
MergeContainedRunnable: The runnable for the `MergeContainedAction`.
MergeDataImpl: Adapter that help to know the way of merge and the editable sides of a difference.
MergeMode: Enumeration of all ways of merging differences.
MergeNonConflictingRunnable: Implements the "merge non-conflicting" and "merge all non-conflicting" action.
MergeOperation: Enumeration of all possible merge operations on differences.
MergePreferencesPage: Preference page for EMFCompare merge.
MergePreviewModeChange
MergeResolutionListenerDescriptor: Describes meta-data about a listener to merge resolution events.
MergeResolutionListenerRegistry: The registry managing the merge resolution extension point information.
MergeResolutionListenerRegistryListener: This class is used for information flow between `MergeResolutionListenerRegistryListener` and `MergeResolutionListenerRegistry` and managing the creation of `IMergeResolutionListener` instances.
MergeResolutionManager: This class manages the detection and handling of merge resolution events.
MergerExtensionRegistryListener: Listener for contributions to the merger extension.
MergeRunnableImpl
MergeViewerItem
MergeViewerItem.Container: Deprecated.
MergeViewerItemProviderConfiguration: Default implementation of `IMergeViewerItemProviderConfiguration`.
MergeViewerUtil
MirrorManager: A manager class for handling the switching of the mirrored mode for each specialized `ContentMergeViewer` and `TextMergeViewer` in EMF Compare,
ModelDependencyProviderRegistry: The registry managing the registered dependency extension point information.
ModelDependencyProviderRegistryListener: This listener will react to changes against the model dependency extension point, allowing us to be in sync with plugin activation and deactivation.
ModelInclusionTesterRegistry: Registry managing the model inclusion testers dependency registered through extension point `org.eclipse.emf.compare.ide.modelInclusionTester`.
ModelMinimizerRegistry: A basic implementation of a registry for model minimizers that stores the model minimizers in a map with their respective class names.
ModelMinimizerRegistryListener: A registry event listener that propagates model minimizers changes from the extension registry to a given model minimizer registry.
ModelResolutionPreferencePage: Preference page for the model resolution, allowing users to disable the resolution altogether or to configure how EMF Compare will handle it.
ModelResolverDescriptor: Descriptor of an `IModelResolver`.
ModelResolverRegistry: This registry implements its own strategy to define the "best" resolver to use.
ModelResolverRegistryListener: This listener will react to changes against our model resolver extension point, allowing us to be in sync with plugin activation and deactivation.
ModelResourceListener: This will listen to workspace changes and react to all changes on "model" resources as determined by `ThreadedModelResolver#MODEL_CONTENT_TYPES`.
ModelResourceVisitor: This implementation of a resource visitor will allow us to browse a given hierarchy and resolve the models files in contains, as determined by `ThreadedModelResolver#MODEL_CONTENT_TYPES`.
ModelsResolution: Computation that resolves 2 or 3 storages (left, right and potentially origin).
NameMatchingStrategy: This implementation of a matching strategy will only use String equality on the resource names to try and find resource mappings.
NameSimilarityMatchingStrategy: This implementation of a matching strategy will try and determine the resource mappings through the similarity of their names.
Navigatable
NoDifferencesCompareInput: A compare input whose purpose is to support a comparison with no differences.
NoDifferencesContentViewer: A `LabelContentViewer` in case of a comparison with no differences.
NoDifferencesViewerCreator: Creates an empty viewer with a single centered label which says there is no differences for the comparison.
NonContainmentRefChangeConflictSearch: Search conflicts for non-containment `ReferenceChange`s.
NonContainmentRefChangeConflictSearch.Add: Search conflicts for non-containment `ReferenceChange` of kind `DifferenceKind.ADD`.
NonContainmentRefChangeConflictSearch.Change: Search conflicts for non-containment `ReferenceChange` of kind `DifferenceKind.CHANGE`.
NonContainmentRefChangeConflictSearch.Delete: Search conflicts for non-containment `ReferenceChange` of kind `DifferenceKind.DELETE`.
NonContainmentRefChangeConflictSearch.Move: Search conflicts for non-containment `ReferenceChange` of kind `DifferenceKind.MOVE`.
NoNotificationParserPool: This implementation of an `XMLParserPool` aims at disabling all notifications when the `option` is set, including the notifications at the very end of parsing.
NoSelectedItemCompareInput: A compare input whose purpose is to support a comparison with no selected items.
NoSelectedItemContentViewer: A `LabelContentViewer` in case of a comparison with no selected item.
NoSelectedItemViewerCreator: Creates an empty viewer with a single centered label which states that there is no selected item.
NotifyingParserPool: This implementation of an XML parser pool will notify a list of `namespace declaration listeners` of all namespaces declared in the parsed resource (xsi:schemalocation), then a list of `proxy creation listeners` of each and every proxy it sees while loading an XML file as an EMF model.
NotLoadedFragmentMatch: The not loaded fragment match.
NotLoadingResourceSet: This implementation of a resource set will be created from a `StorageTraversal`, and only those resources that are part of the traversal will be loaded.
NoVisibleItemCompareInput: A compare input whose purpose is to support a comparison with no visible items.
NoVisibleItemContentViewer: A `LabelContentViewer` in case of a comparison with no visible item.
NoVisibleItemViewerCreator: Creates an empty viewer with a single centered label which say there is no visible item for the comparison.
NullModelMinimizer: An empty implementation of an `IModelMinimizer`.
Objects: Utility method useable on any `Object`.
Objects.ToStringHelper: Fluent interface to build a String representation of an object following the same format as guava's Objects.toStringHelper().
OnlyPseudoConflictsCompareInput: A compare input whose purpose is to support a comparison with only pseudo-conflicts.
OnlyPseudoConflictsContentViewer: A `LabelContentViewer` in case of a comparison with only pseudo-conflicts.
OnlyPseudoConflictsViewerCreator: Creates an empty viewer with a single centered label which says there are only pseudo-conflicts for the comparison.
OSGIVersionUtil: Avoid using org.osgi.framework.Version.compareTo(Version) method to avoid binary incompatibility with OSGi frameworks before they were compiled with Java 5.
OverlayImageProvider: Utility class to externalize the retrieval of difference overlay.
PlatformElementUtil: This provides access to commonly used functions for platform elements, such as adaptation or file lookup.
PluginClassDescriptor<T>: Simple utility class to create proxy of extension that are `instantiable`.
PostProcessorDescriptor: Describes an extension as contributed to the "org.eclipse.emf.compare.rcp.postProcessor" extension point.
PostProcessorDescriptorRegistryImpl<K>: This will contain all of the EMF Compare extensions.
PostProcessorFactoryRegistryListener: This listener will allow us to be aware of contribution changes against the model resolver extension point.
PostProcessorPreferencePage: Preference page used to enable/disable post processor.
PostProcessorRegistryImpl: IPostProcessor.Descriptor.Registry implementation based on wrapping a `IItemRegistry`.
PreferencesPropertyTester: A tester for values of properties.
ProblemIndicationComposite
ProblemIndicationComposite.TextProvider
PropertyContentMergeViewerCreator: An `IViewerCreator` that creates a `PropertyContentMergeViewer`.
PropertySheetAdapterFactory: Specific Adapter factory that provides an `ExtendedPropertySheetPage` for the Compare Editor.
ProximityEObjectMatcher: This matcher is using a distance function to match EObject.
ProximityEObjectMatcher.DistanceFunction: This represent a distance function used by the `ProximityEObjectMatcher` to compare EObjects and retrieve the closest EObject from one side to another.
ProximityIndex: This class is responsible for holding several version of EObjects from sides left, right or origins and provides the ability to return the closest instance (from a difference side) of a given EObject.
ProximityMatchStats: A class responsible for tracking statistics about a given comparison process.
PruningIterator<E>: A specialized tree iterator allowing clients to prune all children below a selected one.
PseudoConflictMerger: A simple merger for pseudo conflict.
RankedAdapterFactoryDescriptor: A descriptor that can create an adapter factory.
RankedAdapterFactoryDescriptor.Registry: A registry is an index that takes a collection of keys, typically a pair consisting of an EPackage or java.lang.Package, and a java.lang.Class, and maps it to a `descriptor`.
RankedAdapterFactoryDescriptorRegistryImpl: The default implementation of the `ComposedAdapterFactory.Descriptor.Registry`.
ReadOnlyGraph<E>: Read-only version of an already existing `Graph`.
RedoAction: An redo action is implemented by using the `CommandStack`.
ReferenceChange: A representation of the model object 'Reference Change'.
ReferenceChangeImpl: An implementation of the model object 'Reference Change'.
ReferenceChangeItemProvider: This is the item provider adapter for a `ReferenceChange` object.
ReferenceChangeItemProviderSpec: Specialized `ReferenceChangeItemProvider` returning nice output for `ReferenceChangeItemProviderSpec.getText(Object)` and `ReferenceChangeItemProviderSpec.getImage(Object)`.
ReferenceChangeMerger: This specific implementation of `AbstractMerger` will be used to merge reference changes.
ReferenceChangeSpec: This specialization of the `ReferenceChangeImpl` class allows us to define the derived features and operations implementations.
ReferenceUtil: This utility class holds methods that will be used by the diff and merge processes.
RemoteMappingContextStorageAccessor: This will use a `RemoteResourceMappingContext` in order to fetch the content of the sides of a comparison during model resolving.
RemoteMonitoredProxyCreationListener: Implementation of `IProxyCreationListener` for remote resources.
RenameDetector: Detector for revealing potential file renames that may have occurred in `IStorageProviderAccessor.DiffSide.SOURCE` or `IStorageProviderAccessor.DiffSide.REMOTE` in the context of a `Subscriber`.
ResolutionUtil: Utility class that provides a few static methods useful for resolving.
ResolvedEvent<T>: Event that indicates that a resource that should be part of a dependency graph has been found.
ResourceAttachmentChange: A representation of the model object 'Resource Attachment Change'.
ResourceAttachmentChangeConflictSearch: Search for `ResourceAttachmentChange` conflicts.
ResourceAttachmentChangeConflictSearch.Add: Search conflicts for `ResourceAttachmentChange` of kind `DifferenceKind.ADD`.
ResourceAttachmentChangeConflictSearch.Change: Search conflicts for `ResourceAttachmentChange` of kind `DifferenceKind.CHANGE`.
ResourceAttachmentChangeConflictSearch.Delete: Search conflicts for `ResourceAttachmentChange` of kind `DifferenceKind.DELETE`.
ResourceAttachmentChangeConflictSearch.Move: Search conflicts for `ResourceAttachmentChange` of kind `DifferenceKind.MOVE`.
ResourceAttachmentChangeImpl: An implementation of the model object 'Resource Attachment Change'.
ResourceAttachmentChangeItemProvider: This is the item provider adapter for a `ResourceAttachmentChange` object.
ResourceAttachmentChangeItemProviderSpec: Specialized `ResourceAttachmentChangeItemProvider` returning nice output for `ResourceAttachmentChangeItemProviderSpec.getText(Object)` and `ResourceAttachmentChangeItemProviderSpec.getImage(Object)`.
ResourceAttachmentChangeMerger: This specific implementation of `AbstractMerger` will be used to merge resource attachment changes.
ResourceAttachmentChangeMergeViewerItem: A specific `MergeViewerItem` for `ResourceAttachmentChange`.
ResourceAttachmentChangeProvider: Legacy Provider to keep backward compatibility with `ResourceAttachmentChangeMergeViewerItem`.
ResourceAttachmentChangeSpec: This specialization of the `ResourceAttachmentChangeImpl` class allows us to define the derived features and operations implementations.
ResourceChangeAdapter: This adapter is supposed to be installed on a `Comparison`'s `ResourceSet`s and their `Resource`s to react to content changes.
ResourceChangeAdapter.IResourceChangeParticipant: A participant in a Resource content change, useful to indicate whether an empty resource must actually be deleted or not, and which other resources need to be deleted/undeleted along.
ResourceComputationScheduler<T>: Class providing facilities to schedule computations and hide as much as possible the multi-threaded complexity.
ResourceComputationScheduler.CallStatus
ResourceComputationScheduler.ComputationState
ResourceComputationScheduler.ShutdownState
ResourceComputationScheduler.ShutdownStatus
ResourceContentsAccessorFactory: A specific `IAccessorFactory` for `ResourceAttachmentChange` objects.
ResourceContentsAccessorImpl: A specific `IResourceContentsAccessor` for `ResourceAttachmentChange` objects.
ResourceDependencyFoundEvent: An event indicating that a resource dependency is found.
ResourceDependencyLocalResolver: The default implementation of the `IResourceDependencyProvider`.
ResourceDependencyProvider: The default implementation of the `IResourceDependencyProvider`.
ResourceDependencyRemoteResolver: The default implementation of the `IResourceDependencyRemoteResolver`.
ResourceLocationChange: A representation of the model object 'Resource Location Change'.
ResourceLocationChangeImpl: An implementation of the model object 'Resource Location Change'.
ResourceLocationChangeItemProvider: This is the item provider adapter for a `ResourceLocationChange` object.
ResourceLocationChangeItemProviderSpec: Specialized `ResourceLocationChangeItemProvider` returning nice output for `ResourceLocationChangeItemProviderSpec.getText(Object)` and `ResourceLocationChangeItemProviderSpec.getImage(Object)`.
ResourceLocationChangeMerger: Deprecated. `ResourceLocationChange`s have been replaced by `ResourceAttachmentChange`s of kind Move.
ResourceLocationChangeSpec: This specialization of the `ResourceLocationChangeImpl` class allows us to define the derived features and operations implementations.
ResourceRemovedEvent<T>: Event indicating that model resources have been removed, which requires updating the graph of dependencies between model resources.
ResourceSetHookRegistry: Resgistry of `IResourceSetHook`.
ResourceSetHookRegistryListener: Listener that fill a `ResourceSetHookRegistry`.
ResourceStreamAccessorImpl: A specific `IStreamContentAccessor` for resources.
ResourceUIUtil: This class will be used to provide various utilities aimed at NotLoadedFragment manipulation.
ResourceUtil: This class will be used to provide various utilities aimed at IResource manipulation.
ResourceVariantStorageProvider: Allows access to the underlying IResourceVariant's storage.
RevealConflictingDiffsAction: This action will reveal in the StructureMergeViewer all other differences conflicting with the currently selected one.
RevisionedURIConverter: This `URIConverter` will be used in order to fetch remote content instead of local content when loading resources.
RootIDMatchingStrategy: This implementation of a matching strategy checks for the IDs of the resources' roots, and consider that resources match if the identifiers of their roots do.
SafeAdapterFactoryItemDelegator: A safe `AdapterFactoryItemDelegator`.
SafeSubMonitor: An EMF `Monitor` that can be safely passed to clients because it will ignore calls to `worked(int)` and `done()` to allow the caller to master the number of ticks consumed, whatever the clients do with the monitor.
SaveComparisonModelAction: Action that manages the save of the comparison model.
ScopeQuery: A class implementing this contract should have the ability to query the scope and tell, from a given EObject, if it is in the scope or not.
SelectAncestorDialog<T>
SelectDiffAction: Action that manages the selection of a difference.
SideLabelProvider
SimilarityComputer: This class is responsible for computing similarities between two text contents and deciding whether they are close enough to be considered a rename.
SingleStructuralFeatureAccessorFactory: A specific `IAccessorFactory` for mono-valued structural feature objects.
SingleStructuralFeatureAccessorImpl: A specific `AbstractStructuralFeatureAccessor` for mono-valued structural feature objects.
SingleValuedAttributeModelUpdateStrategy: A `IModelUpdateStrategy` for single-valued `EAttributes`.
StoragePathAdapter: This will allow us to remember the storage path that allowed us to load a given resource.
StorageTraversal: A Resource Traversal is no more than a set of resources used by the synchronization model to determine which resources to load as part of a given logical model.
StorageTypedElement: Mostly copied from org.eclipse.team.internal.ui.StorageTypedElement.
StorageURIConverter: This implementation of an URI converter will keep track of the storages from which it created input streams.
StrategyResourceMatcher: A `StrategyResourceMatcher` will be used to match two or three `Resource`s together; depending on whether we are doing a two or three way comparison.
StreamAccessorStorage: This implementation of IStorage simply wraps a stream content accessor.
StringAttributeChangeAccessor: A `ITypedElement` that can be used as input of TextMergeViewer.
StringAttributeChangeAccessorFactory: A specific `IAccessorFactory` for string-typed `AttributeChange` objects.
Strings: Utility class for `String`s objects.
StructureMergeViewerFilter: This will be used by the structure viewer to filter out its list of differences according to a number of provided predicates.
StructureMergeViewerGrouper: This class will be used by the EMF Compare UI to group differences together in the structural differences tree viewer.
StyledStringConverter
SubMatchIterable: A custom Iterable that will iterate over the Match->submatch tree of a given Match.
SubMatchIterator: A custom TreeIterator that will iterate over the Match->submatch tree.
SubscriberProviderDescriptor: This class is used for information flow between `SubscriberProviderRegistryListener` and `SubscriberProviderRegistry` and managing the creation of `ISubscriberProvider` instances.
SubscriberProviderRegistry: The registry managing the registered subscriber provider extension point information.
SubscriberProviderRegistryListener: This listener will react to changes against the subscriber provider extension point, allowing us to be in sync with plugin activation and deactivation.
SubscriberStorageAccessor: This is used by our synchronization model to access the innards of Team's `Subscriber`s.
SWTUtil: Utility class for running operation in the UI-Thread if not already within it.
SynchronizationModel: This class acts as a simple DTO that allows us to store the three traversals corresponding to the three sides of a comparison while we build its scope.
SynchronizedResourceSet: A thread-safe implementation of a ResourceSet that will prevent loading of resources unless explicitly demanded through `SynchronizedResourceSet.loadResource(URI)`.
SynchronizerDialog: Dialog used to ask user synchronization behavior.
TableContentMergeViewer
TableContentMergeViewerContentProvider
TableContentMergeViewerCreator: A `IViewerCreator` that creates `TableContentMergeViewer`.
TableMergeViewer: A concrete implementation of `AbstractTableOrTreeMergeViewer` for TableViewer.
TeamSubscriberProvider
TechnicalitiesFilter: A filter used by default that rejects all 'technical' differences.
TextFallbackCompareInput: A highly specialized implementation of a compare input that uses `text input data` to manage the information about the ancestor, left, and right.
TextFallbackCompareInputData: An encapsulation of information about the three sides of a `TextFallbackCompareInput`.
TextFallbackCompareInputLabelProvider: A specialized implementation of a compare input label provider.
TextFallbackCompareViewerCreator
TextFallbackMergeViewer: A highly specialized implementation of a text merge viewer.
ThreadedModelResolver: This implementation of an `IModelResolver` will look up all of the models located in a set container level of the "starting point" (by default, the containing project) to construct the graph of dependencies between these models.
ThreadSafeProgressMonitor
ThreeWayComparisonGroupProvider: This implementation of a `IDifferenceGroupProvider` will be used to group the differences by their `side` : left, right and conflicts.
ThreeWayComparisonGroupProvider.CompositeConflict: This extension of `Conflict` is used to handle `refined` diffs and to join conflicts for the SMV.
ThreeWayComparisonGroupProvider.ConflictsGroupImpl: Specialized `BasicDifferenceGroupImpl` for Conflicts.
ThreeWayTextDiff: Three-way differencing utility for plain text.
TooltipLabelAdapterFactory: SuperClass of factories that need to access tooltips labels.
TracingConstant: Store constant used to display or not a trace.
TransactionalDualCompareCommandStack: `ICompareCommandStack` implementation that will delegate to two given command stacks; one for each side of the comparison.
TreeCompareInputAdapterFactory
TreeContentMergeViewer: Specialized `ContentMergeViewer` that uses `TreeViewer` to display left, right and ancestor `EObject`.
TreeContentMergeViewerContentProvider: An `IMergeViewerContentProvider` that delegates `getXXXImage(Object)` and `getXXXText()` to a `CompareConfiguration`.
TreeContentMergeViewerCreator: A `IViewerCreator` that creates `TreeContentMergeViewer`.
TreeContentMergeViewerItemLabelProvider: Label Provider for `IMergeViewerItem`s.
TreeItemProviderAdapterFactorySpec: A specific implementation of `TreeItemProviderAdapterFactory`.
TreeMergeViewer: A concrete implementation of `AbstractTableOrTreeMergeViewer` for TreeViewer.
TreeMergeViewerItemContentProvider: ContentProvider for `IMergeViewerItem`s which uses their 'left', 'right' and 'ancestor' sides in combination with the given `AdapterFactory` to create the children and parent `IMergeViewerItem`s.
TreeNodeCompareInput
TreeNodeCompareInputLabelProvider: Provides labels for the content viewer pane.
TreeNodeImpl: An implementation of the model object 'Node'.
TreeNodeItemProviderSpec: A specific implementation of `TreeNodeItemProvider`.
TypeConstants: Constants used by org.eclipse.emf.compare.rcp.ui.contentmergeviewer.accessor.legacy.ITypedElement implementations.
TypedNotifier: A specific implementation of `AbstractTypedElementAdapter` for notifiers.
UndoAction: An undo action is implemented by using the `CommandStack`.
URIDistance: This class is able to measure similarity between "URI like" strings, basically strings separated by "/".
URIStorage: This implementation of an `IStorage` will allow us to keep track of the `URIHandler` that's been used to load a given URI from this uri converter.
UseIdentifiers: This can be used to tell EMF Compare which strategy should be used when matching the EObjects as regards the identifier.
WaitContentViewer: A `LabelContentViewer` in case of a comparison with no differences.
WeightProvider: Provide the weight to consider while comparing EObjects by their content.
WeightProvider.Descriptor: Wrapper describing the given weight provider.
WeightProvider.Descriptor.Registry: Registry of weight provider descriptors.
WeightProviderDescriptorImpl: A simple implementation of `WeightProvider.Descriptor` that will delegate its method implementation to values given to its constructor.
WeightProviderDescriptorRCPImpl: Describes an extension as contributed to the "org.eclipse.emf.compare.rcp.weightProvider" extension point.
WeightProviderDescriptorRegistryImpl: This will contain all of the EMF Compare Weight Providers Descriptors.
WeightProviderDescriptorRegistryListener: Listener for contributions to the match engine extension.
WrappableTreeViewer: This class is not intended to be used outside of its package.
WrapperItemDescriptor<T>: A `IItemDescriptor` that wrap one instance of an item and return the same item each time.