All Classes and Interfaces
Class
Description
An abstract implementation of
IAccessorFactory.Factory of difference extensions.
Abstract class that redefines
AbstractCompareECrossReferencerAdapter.handleContainment(org.eclipse.emf.common.notify.Notification) to
mimic EContentAdapter behavior.This implementation of
IComparisonScope can be sub-classed in order to avoid re-implementing some
of the methods imposed by this interface.Abstract composite that is used to configure an item.
Class in charge of finding conflicting diffs for a given diff of type T.
An abstract implementation of
IContextTester that provides convenience methods for retrieving
values from the context map.This command can be used to copy a number of diffs (or a single one) in a given direction.
An abstract filter implementation.
Abstract implementation of
IDifferenceGroupProvider.Abstract subclass of
CompareEditorInput to be use to open CompareEditor with results of EMF
Compare.Abstract class for an
IItemDescriptor.Abstract implementation of the handling of editors' activations, for the Logical Model View.
Abstract
MergeAction for merging all diffs contained in the selection.Abstract implementation of an
IMerger.Provides inheritable default behavior for the merge runnables.
An abstract implementation of
IMergeViewer.This can be subclassed instead of
IModelResolver to avoid reimplementing common extension-related
code.Asbtract super-class of
IProxyCreationListeners to use for computing the logical model.Abstract utility class to listen to the
IExtensionRegistry.Enumeration that says if the
IConfigurationElement is to be added or removed from the
IExtensionRegistry.Abstract super-class of resolving computations.
Abstract implementation of
IResourceSetHook.An abstract implementation of
IStructuralFeatureAccessor.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>
A wrapper of Table Item or Tree Item.
An abstract specialization of
AbstractStructuredMergeViewer for Tables or Trees.A specific implementation of
IElementComparer that compare EMF Compare Viewer Items.This will be used in order to resize the table items to an even height.
An abstract implementation of
ITypedElement.Abstract implementation which is parameterized to set weights based on features, to ignore features and
consider "name" features as more important.
A Map acting like a LRU cache which will evict elements which have not been accessed in a while.
The default concrete implementation of
AbstractRegistryEventListener.The default implementation of
IAccessorFactory.Registry.Preferences page used to enable/disable adapter factories that have been contributed to EMF Compare.
Deprecated.
This specific implementation of
AbstractMerger will be used to merge conflicts in an additive merge
context.Merge Criterion that indicates we want to perform an 'Additive' merge.
This specific implementation of
AbstractMerger will be used to merge reference changes in an
additive merge context.This specific implementation of
AbstractMerger will be used to merge resource attachment changes in
an additive merge context.A representation of the model object 'Attribute Change'.
Search conflicts for
AttributeChanges.Search conflicts for
AttributeChange of kind DifferenceKind.ADD.Search conflicts for
AttributeChange of kind DifferenceKind.CHANGE.Search conflicts for
AttributeChange of kind DifferenceKind.DELETE.Search conflicts for
AttributeChange of kind DifferenceKind.MOVE.An implementation of the model object 'Attribute Change'.
This is the item provider adapter for a
AttributeChange object.Specialized
AttributeChangeItemProvider returning nice output for AttributeChangeItemProviderSpec.getText(Object) and
AttributeChangeItemProviderSpec.getImage(Object).This specific implementation of
AbstractMerger will be used to merge attribute changes.This specialization of the
AttributeChangeImpl class allows us to define the derived features and
operations implementations.This implementation of a
IDifferenceGroup uses a predicate to filter the whole list of differences.A simple implementation of
IPostProcessor.Descriptor that will delegate its method implementation to values given
to its constructor.This implementation of an
IBatchMerger leaves some choice to the client as to what should be
merged.This implementation of a
IDifferenceGroupProvider will be used to
group the differences by their Resource.Specialized
BasicDifferenceGroupImpl for Resources.An implementation of EObjectIndex which segregates given EObjects using their type and then delegate to
other indexes.
A computer implementation to cache the relationship of diffs.
This class wraps a DistanceFunction and cache its result.
An implementation of the
IImplicitDependencies that delegates the respective dependency calculation
to a given object and caches the results to increase performance.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).
Event to notify a color change.
An event that can be passed to
CommandStackListener.commandStackChanged(EventObject).An event type.
Implementation of
IMergeViewerItemProvider which extracts the IMergeViewerItems from
ICompareAccessors.The Adapter Factory for the model.
Default implementation that use a cache to store created Color and that is listening to a preference store
for color configuration.
A simple
ICompareCommandStack that delegate execution to another command stack but keep
informations about execution to properly reply to ICompareCommandStack protocol.Simple data structure acting like a command stack but without any execution capability.
The Factory for the model.
An implementation of the model Factory.
This is the factory that is used to provide the interfaces needed to support Viewers.
Specialized
CompareItemProviderAdapterFactory returning ItemProviderAdapter with nice
IItemLabelProvider.getText(Object) and
IItemLabelProvider.getImage(Object).The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
The Switch for the model's inheritance hierarchy.
A representation of the model object 'Comparison'.
A specific
IAccessorFactory for
Comparison objects.Exception used to manage cancellation of comparison operations.
An implementation of the model object 'Comparison'.
Index of diffs in a comparison.
This is the item provider adapter for a
Comparison object.Specialized
ComparisonItemProvider returning nice output for ComparisonItemProvider.getText(Object) and
ComparisonItemProvider.getImage(Object).This will be used by EMF Compare in order to construct its comparison scope given a "starting point".
CompareEditorInput that will compute the result of the comparison of the given scope with the given
comparator.
This specialization of the
ComparisonImpl class allows us to define the derived features and
operations implementations.This utility class provides common methods for navigation over and querying of the Comparison model.
Composed styled string implementation backed by an
ArrayList.This class encapsulates a list of model minimizers and propagates any calls to each element in the list.
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.
Registry event listener used for
IConfiguratorUIRegistryA representation of the model object 'Conflict'.
An implementation of the model object 'Conflict'.
This is the item provider adapter for a
Conflict object.Specialized
ConflictItemProvider returning nice output for ConflictItemProviderSpec.getText(Object) and
ConflictItemProviderSpec.getImage(Object).A representation of the literals of the enumeration 'Conflict Kind',
and utility methods for working with them.
This specific implementation of
AbstractMerger will be used to merge real conflicts.This class is wrapper for TreeNode used to represent a conflict TreeNode.
Factory for ConflictSearch classes.
This specialization of the
ConflictImpl class allows us to define the derived features and
operations implementations.Search conflicts for containment
ReferenceChanges.Search conflicts for containment
ReferenceChange of kind DifferenceKind.ADD.Search conflicts for containment
ReferenceChange of kind DifferenceKind.CHANGE.Search conflicts for containment
ReferenceChange of kind DifferenceKind.DELETE.Search conflicts for containment
ReferenceChange of kind DifferenceKind.MOVE.A specific
IAccessorFactory for
containment ReferenceChange objects.A specific
AbstractStructuralFeatureAccessor for containment
ReferenceChange objects.The generic descriptor for content merge viewer customizations.
The registry responsible for managing the content merge viewer customizations.
The listener responsible for handling registration events regarding content merge viewer customizations.
Utility class for evaluating context testers in adapter factory descriptors.
Deprecated.
Use
MergeCommand instead.Defines the scope for the resolution of a file's logical model.
POJO used to hold data from preference page.
A default implementation of
IComparisonFactory that creates a new Comparison through the
default CompareFactory.This is the default implementation of an
IComparisonScope.The conflict detector is in charge of refining the Comparison model with all detected Conflict between its
differences.
The diff engine is in charge of actually computing the differences between the objects mapped by a
Match object.Default implementation of
IEqualityHelperFactory.The requirements engine is in charge of actually computing the equivalences between the differences.
This implementation of a
IDifferenceGroupProvider will be used as
the default group provider.Default implementation of
IImplicitDependencies, which uses the extensions collected by the
registry of the modelDependencyProvider extension point.The Match engine orchestrates the matching process : it takes an
scope as input,
iterates over its left, right and
origin roots and delegates to IResourceMatchers and
IEObjectMatchers in order to create the result Comparison model for this scope.IConfiguratorUIFactory for
DefaultRCPMatchEngineFactoryImplementation of
IMatchEngine.Factory for the DefaultMatchEngine that can be configured.The requirements engine is in charge of actually computing the requirements between the differences.
Default implementation of
IResolutionContext.The default implementation of
WeightProvider applicable to
all objects.Abstract implementation that forward method calls to a
delegatating
CommandStack.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.This implementation of
ITreeContentProvider delegates to the IMergeViewerItemProviders and
IMergeViewerItemContentProviders registered via the content merge viewer customization extension
point.This implementation of an
URI Converter will delegate all calls to another.Event indicating a dependency between two resources has been found.
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.
This class is used for information flow between
ModelDependencyProviderRegistryListener and
ModelDependencyProviderRegistry and managing the creation of IDependencyProvider instances.Base class for Descriptor Registry.
Encapsulated a diagnostic to hide multi-threaded details.
A representation of the model object 'Diff'.
Class containing the diff, match and patch methods.
Class representing one diff operation.
Internal class for returning results from diff_linesToChars().
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."
Class representing one patch operation.
This default implementation of an
IDiffProcessor will build the necessary differences and attach
them to the appropriate Match.This implementation of an
ECrossReferenceAdapter will allow us to only
attach ourselves to the Diff elements.The default implementation of
IDifferenceFilterChange.Utility class to listen to the
IDifferenceFilter.Registry.Manager of filters.
The default implementation of the
IDifferenceFilter.Registry.Implementation of
IDifferenceGroupProvider.Descriptor.The default implementation of the
IDifferenceGroupExtender.Registry.Utility class to listen to the
IDifferenceGroupProvider.Descriptor.Registry
.This manager can be used to modify EMF Compare UI behavior regarding groups.
The default implementation of
IDifferenceGroupProviderChange.Utility class to listen to the
IDifferenceGroupProvider.Descriptor.Registry.Implementation of the
IDifferenceGroupProvider.Descriptor.Registry.A representation of the literals of the enumeration 'Difference Kind',
and utility methods for working with them.
A representation of the literals of the enumeration 'Difference Source',
and utility methods for working with them.
A representation of the literals of the enumeration 'Difference
State', and utility methods for working with them.
An implementation of the model object 'Diff'.
This is the item provider adapter for a
Diff object.This class is wrapper for TreeNode used to represent a diff TreeNode.
A computer implementation to calculate the relationship of differences in EMF Compare.
A change for
IDiffRelationshipComputer.This specialization of the
DiffImpl class allows us to define the derived features and operations
implementations.A custom iterator that will walk a Match->submatch tree, and allow iteration over the Diffs of these
Matches.
This utility class will be used to provide similarity implementations.
Deprecated.
Not intendended to be used by clients
A
ResourceSet that offers a dispose method.Action that manages the dropdown menu that allows to show the consequences of an accept or a reject.
ICompareCommandStack implementation that will delegates to two given command stacks; one for each
side of the comparison.Utility class to access (R/W) field in super class hierarchy.
The implementation of
WeightProvider applicable to all ecore
objects.This distance function implementation will actually compare the given EObject.
Builder class to configure an EditionDistance instance.
Preference page for UI settings related to the comparison editor.
This class serves as the main entry point of a comparison.
A Builder pattern to instantiate EMFCompare objects.
Engine provider.
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.
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.
This defines the semantics of an EObject copy in the case of EMF Compare.
A wrapper interface for
DeferredTreeContentManager which enables EMFCompare to switch between its own and the default platform
implementation.The default implementation of
EMFCompareDeferredTreeContentManager forwards to
DeferredTreeContentManager.Provider Service for
EMFCompareDeferredTreeContentManagers.Util Class for handling
EMFCompareDeferredTreeContentManagerProvider service.A specific canvas that must be presented next to a TreeViewer.
Default implementation that use a change recorder in the background to record the changes made by executed
commands.
Utility class to access externalized Strings for this bundle.
Handle, for the Logical Model View, the EMF Compare editor activations.
This is the central singleton for the Compare edit plugin.
The actual implementation of the Eclipse Plugin.
The activator class controls the plug-in life cycle.
Utility class to access externalized Strings for this bundle.
The activator class, controls the plug-in life cycle.
This class will provide a number of Predicates that can be used to retrieve particular
Diffs from
an iterable.Mimics the Log4J 1 logger interface but sends all logging to the Eclipse log.
Utility class to access externalized Strings for EMF Compare's core.
Deprecated.
this class provides Guava predicates.
Global preference page for EMF Compare
Preferences constants and utilities for the EMF Compare RCP plug-in.
This class exposes methods to serialize a "human-readable" form of the comparison model onto a given
stream.
Utility class to access externalized Strings for EMF Compare's ide integration.
This is the central singleton for the EMF Compare RCP plugin.
Utility class to access externalized Strings for EMF Compare's rcp ui integration.
The activator class controls the plug-in life cycle.
Implementation of
AbstractStructuredViewerWrapper.Specialized AdapterFactoryContentProvider for the emf compare structure merge viewer.
Enum used for better readability of the method
EMFCompareStructureMergeViewerContentProvider.runWhenReady(CallbackType, Runnable).A specialized
AdapterFactoryLabelProvider.FontAndColorProvider for the structure merge viewer.A compound command that updates the value of a feature associated with a diff and rejects the diff
itself.
Set of preferences affecting the behavior of the EMF Compare user interface.
This will be used to initialize all of our UI preferences to their default.
Handles the comparison between selections adapting to
IEMFComparisonSources.Provides adapters for the
EMFModelProvider.This implementation of a
ModelProvider will be used to provide the logical model associated with
EMF models.Property tester specifying whether an
IFile should be treated as EMF model resource and hence
should be handled by EMF Compare.Handle, for the Logical Model View, the EMF Reflective editors' activations.
This will be used to represent an EMF resource's mapping.
A customized merger for the
EMFResourceMappings.Allows us to provide comparison support for the EMF model provider.
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.
An empty difference group provider.
Preference page for engines preferences
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.
An enumeration used in the API to specify sides.
Static utilities to create human readable EObject.toString() methods.
EMF Compare needs its own rules for "equality", which are based on similarity instead of strict equality.
Compute specific matching rules.
Wrapper describing the given equality helper extension provider.
Registry of equality helper extension provider descriptors.
Enumeration used to return the result of a specific matching.
Describes an extension as contributed to the "org.eclipse.emf.compare.rcp.equalityHelperExtensionProvider"
extension point.
This will contain all of the EMF Compare equality helper extension provider descriptors.
Listener for contributions to the match engine extension.
A representation of the model object 'Equivalence'.
An implementation of the model object 'Equivalence'.
This is the item provider adapter for a
Equivalence object.A function computing an URI Fragment.
This provides access to commonly used functions which need to handle exceptions.
Handle, for the Logical Model View, the item(s) selected in Project Explorer View or Package Explorer View.
An item provider adapter factory delegator that supports our custom item provider interfaces:
IItemStyledLabelProvider, IItemDescriptionProvider and ISemanticObjectLabelProvider
.And extended
ItemProviderDecorator that provides an OverlayImageProvider and and
ExtendedAdapterFactoryItemDelegator.FeatureFilters will be used by the default implementation of a diff engine in order to determine
which features it is to check for differences.This will be used to attach the FeatureFilter to its comparison so that it can be used after the diff
process.
A representation of the model object 'Feature Map Change'.
Search conflicts for
FeatureMapChanges.Search conflicts for
FeatureMapChange of kind DifferenceKind.ADD.Search conflicts for
ReferenceChange of kind DifferenceKind.CHANGE.Search conflicts for
FeatureMapChange of kind DifferenceKind.DELETE.Search conflicts for
FeatureMapChange of kind DifferenceKind.MOVE.An implementation of the model object 'Feature Map Change'.
This is the item provider adapter for a
FeatureMapChange object.Specialized
FeatureMapChangeItemProvider returning nice output for FeatureMapChangeItemProviderSpec.getText(Object) and
FeatureMapChangeItemProviderSpec.getImage(Object).This specific implementation of
AbstractMerger will be used to merge attribute changes.A specific
IAccessorFactory for
FeatureMapChanges of kind DifferenceKind.MOVE (represent an entry that moved from map to another).This specialization of the
FeatureMapChangeImpl class allows us to define the derived features and
operations implementations.A specific
IAccessorFactory for
FeatureMapChanges of kind DifferenceKind.CHANGE (represent a value that changed his key).A specific
AbstractStructuralFeatureAccessor for FeatureMapChanges of kind DifferenceKind.CHANGE
(represent a value that changed his key).Allows access to the underlying IFileRevision's storage.
These will be the actual actions displayed in the filter menu.
This will be displayed atop the structure viewer as the "filters" menu.
This implementation of an
IComparisonScope can be provided specific filters to filter out parts of
the Notifiers' content lists.A wrapper for a
TreeIterator that only returns nodes that satisfy a predicate and skips all others
and their descendants.Preference page for
IDifferenceFilter.A property change listener that listens specifically for the property indicating that compare
configuration's {@link ForwardingCompareConfiguration#isMirrored()isMirrored} value has changed.
Deprecated.
Use
IItemProviderDecorator and
DecoratorAdapterFactory instead.This implementation of an
XMLDefaultHandler will forward all calls to its delegate.This implementation of an
XMLHandler will forward all calls to its delegate.This implementation of an
XMLHelper will forward all calls to its delegate.This structure will be used to maintain a undirected graph of elements.
This action will allow us to group differences by their kind.
This menu will display actions that will allow the user to group differences together.
An specific
ItemProviderAdapter for groups.Interactive content used for
IDifferenceGroupProvider preferences.Preference page for group providers.
A factory of
ITypedElements.The registry of
IAccessorFactory.The use case for this feature is really specific : it is used when a user use git to create branch
representing feature releases.
This interface describes the general contract of what EMF Compare expects in order to "copy all" diffs from
a given Comparison or list.
An
IChangeFactory is a factory capable to create an extension from a Diff if
and only if this factory can handle the given Diff.A event notifying the bus that some color have change their value.
An ICompareAccessor is an
ITypedElement used to present an input object in the EMF Compare UI.Implementation of this interface will return color of decorator of
difference.A provider of ICompareColor.
An extended
command stack that knows about each save state of the comparison.Interface of compare copy (merge) command.
Something like EMF's
EditingDomain but dedicated to the handling of
comparison merging and undoing / redoing those merge.Marker interface for all events related to EMF Compare.
A factory for
Comparison.Specific comparison input that can be used to directly provide a pre-computed Comparison to the EMF Compare
UI.
This class defines the expected contract of EMF Compare scopes.
The scope of a model comparison.
Encapsulates the logic of a computation that can be identified by a key.
Factory for
AbstractConfigurationUI.This class defines the general contract of a Conflict detector.
A tester to evaluate whether a given context matches certain criteria.
A
IDifferenceFilter that can be fully deactivated in the preferences.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.
This implementation of an
IEObjectMatcher will create Matches based on the input EObjects
identifiers (either XMI:ID or attribute ID) alone.The default function used to retrieve IDs from EObject.
Contract for clients of the org.eclipse.emf.ecompare.ide.ui.modelDependencies extension point.
An element that can hold a diagnostic.
This class defines the general contract of a Differencing engine.
Instances of this class will be used by EMF Compare in order to provide difference filter facilities to the
structural differences view.
A registry of
IDifferenceFilter.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.
This interface represents an EMF Compare "group" of differences that can be displayed in the structural
differences viewer of the UI.
Instances of this class will be used by EMF Compare in order to extend the children of TreeNodes containing
in the structure merge viewer.
A registry of
IDifferenceGroupExtender.Instances of this class will be used by EMF Compare in order to provide difference grouping facilities to
the structural differences view.
Type of comparison a
IDifferenceGroupProvider can handle.A descriptor that can create adifference group provider.
A registry of
IDifferenceGroupProvider.Extended interface of
IDifferenceGroupProvider that gives information on the building status of its
groups.Stores selected
IDifferenceGroupProvider.An
IDiffProcessor is meant to be used in order to react to the detection of differences by the diff
engine.A computer to retrieve the dependent diffs, resulting merges and resulting rejections for a diff.
Event indicating a change in
IDiffRelationshipComputer.Engine provider for EMF Compare.
This adapter is used by EMFCompare to check if a compare button especially for EMFCompare should be added.
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.Use to compare objects by the
IMatchEngine.A factory that instantiate IEqualityHelper.
.
Interface of a directed graph.
Graph consumer, that maintains the state of a graph created by a third party.
Read-only view of a
Graph.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.
This is the interface implemented to provide a description for an item.
An item descriptor.
Item registry.
This is the interface implemented to provide a styled label for an item.
A policy that can be asked to if it is authorizing resource to be loaded on demand.
A registry of policy.
Handle, for the Logical Model View, the editors activations and the selections of items.
This class defines the general contract of a Matching engine.
Wrapper describing the given match engine.
A registry of
IMatchEngine.Factory.The basic contract for a "merge all non-conflicting" differences.
Criterion for describing a merge operation.
This interface is used to select mergers according to some criterion.
Interface implemented by
MergeDataImpl.Handles a list of merge options.
Mergers are used by EMF Compare to merge specific differences from one side to the other.
This will hold all registered mergers.
Registry that can provide its mergers sorted by rank descending.
A default implementation of an
IMerger.Registry.This adds the ability for
mergers to define their own sub-set of "required" differences.Provides an interface for listening to the events of a successful merge resolution.
Interface for executing merge commands from the
ICompareEditingDomain.A specific
IInputSelectionProvider for EMF Compare.An enum that represents the side of the viewer and provides utilty methods to manage sides.
An IMergeViewerItem associate a Diff and its left side, right side and ancestor side values.
Deprecated.
IMergeViewerItem.Container is no longer needed since its functionality is now provided by
IMergeViewerItemContentProvider.Interface for specialized
tree content providers for the comparison content
merge viewer.The contract for providers responsible for determining root elements in merge viewers.
The configuration used by
IMergeViewerItemContentProviders.A model tester specifies whether an
IFile shall be considered as EMF Model or not.This can be used in order to tell EMF Compare how to minimize the logical model to a reduced set of
resources.
A registry for model minimizers.
This can be used in order to tell EMF Compare how the logical model of a given file can be resolved in its
entirety.
A strategy for updating the model with changes made from within a content merge viewer.
Provider for
model update strategies.The listener interface for receiving namespace declaration events from the XML parsers.
A User interface that holds a viewer and satellites elements.
Builder for an Interactive UI.
A contract for a provider which can indicate whether it wants to handle a certain object.
Implementations of this interface can be used in order to tell EMF Compare how to make post treatments at
each step of the comparison.
Wrapper describing the given post processor.
Registry of post processor.
Describes the contract for a proxy creation listener as can be notifier from this pool's created parsers.
This class defines the general contract of a Requirements engine.
A resolution context provides the different elements that can be involved in a comparison taking logical
models into account.
A specific
ICompareAccessor for resource contents.A resource dependency provider is in charge of providing the dependencies of resources (local or remote
resources, remote meaning hosted in git for instance).
A resource dependency provider is in charge of providing the dependencies of resources (local or remote
resources, remote meaning hosted in git for instance).
A resource dependency provider is in charge of providing the dependencies of resources (local or remote
resources, remote meaning hosted in git for instance).
An
IResourceMatcher will be used to match two or three
Resources together; depending on whether we are doing a two or three
way comparison.A
StrategyResourceMatcher will be used to match two or three Resources together; depending
on whether we are doing a two or three way comparison.Interface used to hook some behavior into the
ResourceSet used by EMF Compare when using logical
model.Provider of labels for semantic objects.
This class is a wrapper used to create different kind of StoragePathAdapter depending on the needs.
Some implementations of IStorage provide a plain erroneous
path..
Used by the logical model to wrap types that can provide IStorages.
This will be used by URI Converters in order to retrieve the storages for the files it seeks.
Used by the resolution process to determine the side of the revision to fetch.
An
IStreamContentAccessor object represents a set of bytes which can be accessed by means of a
stream.A specific
ICompareAccessor for structural features.Utility class that mimics the JFace's StyledString.
An iterable of
IStyledString.A style class for
IStyledString.The possible styles of the border.
A
IStyledString.Style builder.The possible styles of the underline.
Contract for clients of the org.eclipse.emf.ecompare.ide.ui.subscriberProvider extension point.
Label provider for
IItemDescriptor.Registry holding
IItemDescriptor.Util class for item.
Provider of tooltips.
Interface for getting the name, image, and type for an object.
This implementation of a
IDifferenceGroupProvider will be used to
group the differences by their kind : additions, deletions, changes and moves.A dummy viewer that displays a single label.
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.
Descriptor for an item.
Extends
diff_match_patch with a line-based diffing capability.A default implementation that uses a map internally.
A listener for load on demand policy extension point.
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).
Called by EMF Compare in order to resolve the logical models corresponding to the given IResources.
Implementation of
IProxyCreationListener for local resolutions.This implementation of a matching strategy will only use String equality on the resource URIs to try and
find resource mappings.
Preference page used to configure logging in EMFCompare.
A simple view displaying the resources of a logical model.
Presentation mode of the viewer.
ContentProvider for the logical model view.
Descriptor of an
ILogicalModelViewHandler.This registry implements its own strategy to define the "best" Logical Model Editors Handler to use.
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.
Util methods, for the Logical Model View handlers.
LabelProvider for the logical model view.
A specific
IAccessorFactory for
multi-valued structural feature objects.A specific
AbstractStructuralFeatureAccessor for multi-valued structural feature objects.A representation of the model object 'Match'.
A specific
ICompareAccessor for Match objects.A specific
IAccessorFactory for
Match objects.Implementators of this interface might provide elements to be matched "ahead of time".
This conflict detector searches for conflicting
Diffs in the same Match as the current
Diff, as well as among ReferenceChanges that reference the same EObject as the
current Diff, if it is a ReferenceChange.This implementation of an
ECrossReferenceAdapter will allow us to only
attach ourselves to the Match elements.Descriptor for
IMatchEngine.Factory.The default implementation of the
IMatchEngine.Factory.Registry.The default implementation of the
IMatchEngine.Factory.Registry.Listener for contributions to the match engine extension.
MatchEnginefactoryRegistry that wrap an IItemRegistry<IMatchEngine.Factory>.
An implementation of the model object 'Match'.
This is the item provider adapter for a
Match object.Specialized
MatchItemProvider returning nice output for MatchItemProviderSpec.getText(Object) and
MatchItemProviderSpec.getImage(Object).This class is wrapper for TreeNode used to represent a match TreeNode.
Specific
Adapter to Matches that are related to containment ReferenceChanges (that
are placed in their parent Match).Process a comparison to detect
Matches related to containment ReferenceChange.A representation of the model object 'Match Resource'.
A specific
IAccessorFactory for
MatchResource objects.An implementation of the model object 'Match Resource'.
This is the item provider adapter for a
MatchResource object.Specialized
MatchResourceItemProvider returning nice output for MatchResourceItemProviderSpec.getText(Object) and
MatchResourceItemProviderSpec.getImage(Object).This class is wrapper for TreeNode used to represent a match resource TreeNode.
This specialization of the
MatchImpl class allows us to define the derived features and operations
implementations.This utility class holds methods that will be used by the diff and merge processes.
Abstract Action that manages a merge of a difference in case of both sides of the comparison are editable.
Action that manages a merge of a all non-conflicting difference.
A merge command that merges all non-conflicting differences of the given comparison in either direction.
Exception that indicates that a merge cannot be performed because it would lead to involuntarily resolving
a conflict.
A merge command that delegates it
MergeCommand.doExecute() to the
IMergeRunnable.merge(List, boolean, IMerger.Registry) method.Implements the "merge all contained conflicting" action.
This action will merge all differences contained in the selection, regardless of conflicts or originating
side.
Action that manages a merge of a contained conflicting differences in case the selection is a resource
match or a model element match.
Action that manages a merge of a contained non-conflicting difference in case the selection is a resource
match or a model element match.
The runnable for the
MergeContainedAction.Adapter that help to know the way of merge and the editable sides of a difference.
Enumeration of all ways of merging differences.
Implements the "merge non-conflicting" and "merge all non-conflicting" action.
Enumeration of all possible merge operations on differences.
Preference page for EMFCompare merge.
Describes meta-data about a listener to merge resolution events.
The registry managing the merge resolution extension point information.
This class is used for information flow between
MergeResolutionListenerRegistryListener and
MergeResolutionListenerRegistry and managing the creation of IMergeResolutionListener
instances.This class manages the detection and handling of merge resolution events.
Listener for contributions to the merger extension.
Deprecated.
Default implementation of
IMergeViewerItemProviderConfiguration.A manager class for handling the switching of the mirrored mode for each specialized
ContentMergeViewer and TextMergeViewer in EMF Compare,The registry managing the registered dependency extension point information.
This listener will react to changes against the model dependency extension point, allowing us to be in sync
with plugin activation and deactivation.
Registry managing the model inclusion testers dependency registered through extension point
org.eclipse.emf.compare.ide.modelInclusionTester.A basic implementation of a registry for model minimizers that stores the model minimizers in a map with
their respective class names.
A registry event listener that propagates model minimizers changes from the extension registry to a given
model minimizer registry.
Preference page for the model resolution, allowing users to disable the resolution altogether or to
configure how EMF Compare will handle it.
Descriptor of an
IModelResolver.This registry implements its own strategy to define the "best" resolver to use.
This listener will react to changes against our model resolver extension point, allowing us to be in sync
with plugin activation and deactivation.
This will listen to workspace changes and react to all changes on "model" resources as determined by
ThreadedModelResolver#MODEL_CONTENT_TYPES.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.Computation that resolves 2 or 3 storages (left, right and potentially origin).
This implementation of a matching strategy will only use String equality on the resource names to try and
find resource mappings.
This implementation of a matching strategy will try and determine the resource mappings through the
similarity of their names.
A compare input whose purpose is to support a comparison with no differences.
A
LabelContentViewer in case of a comparison with no differences.Creates an empty viewer with a single centered label which says there is no differences for the comparison.
Search conflicts for non-containment
ReferenceChanges.Search conflicts for non-containment
ReferenceChange of kind DifferenceKind.ADD.Search conflicts for non-containment
ReferenceChange of kind DifferenceKind.CHANGE.Search conflicts for non-containment
ReferenceChange of kind DifferenceKind.DELETE.Search conflicts for non-containment
ReferenceChange of kind DifferenceKind.MOVE.This implementation of an
XMLParserPool aims at disabling all
notifications when the option is set, including the notifications
at the very end of parsing.A compare input whose purpose is to support a comparison with no selected items.
A
LabelContentViewer in case of a comparison with no selected item.Creates an empty viewer with a single centered label which states that there is no selected item.
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.The not loaded fragment match.
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.A compare input whose purpose is to support a comparison with no visible items.
A
LabelContentViewer in case of a comparison with no visible item.Creates an empty viewer with a single centered label which say there is no visible item for the comparison.
An empty implementation of an
IModelMinimizer.Utility method useable on any
Object.Fluent interface to build a String representation of an object following the same format as guava's
Objects.toStringHelper().
A compare input whose purpose is to support a comparison with only pseudo-conflicts.
A
LabelContentViewer in case of a comparison with only pseudo-conflicts.Creates an empty viewer with a single centered label which says there are only pseudo-conflicts for the
comparison.
Avoid using org.osgi.framework.Version.compareTo(Version) method to avoid binary incompatibility with OSGi
frameworks before they were compiled with Java 5.
Utility class to externalize the retrieval of difference overlay.
This provides access to commonly used functions for platform elements, such as adaptation or file lookup.
Simple utility class to create proxy of extension that are
instantiable.Describes an extension as contributed to the "org.eclipse.emf.compare.rcp.postProcessor" extension point.
This will contain all of the EMF Compare extensions.
This listener will allow us to be aware of contribution changes against the model resolver extension point.
Preference page used to enable/disable post processor.
IPostProcessor.Descriptor.Registry implementation based on wrapping a
IItemRegistry.A tester for values of properties.
An
IViewerCreator that creates a PropertyContentMergeViewer.Specific Adapter factory that provides an
ExtendedPropertySheetPage for the Compare Editor.This matcher is using a distance function to match EObject.
This represent a distance function used by the
ProximityEObjectMatcher to compare EObjects and
retrieve the closest EObject from one side to another.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.
A class responsible for tracking statistics about a given comparison process.
A specialized tree iterator allowing clients to prune all children below a selected one.
A simple merger for pseudo conflict.
A descriptor that can create an adapter factory.
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.The default implementation of the
ComposedAdapterFactory.Descriptor.Registry.Read-only version of an already existing
Graph.An redo action is implemented by using the
CommandStack.A representation of the model object 'Reference Change'.
An implementation of the model object 'Reference Change'.
This is the item provider adapter for a
ReferenceChange object.Specialized
ReferenceChangeItemProvider returning nice output for ReferenceChangeItemProviderSpec.getText(Object) and
ReferenceChangeItemProviderSpec.getImage(Object).This specific implementation of
AbstractMerger will be used to merge reference changes.This specialization of the
ReferenceChangeImpl class allows us to define the derived features and
operations implementations.This utility class holds methods that will be used by the diff and merge processes.
This will use a
RemoteResourceMappingContext in order to fetch the content of the sides of a
comparison during model resolving.Implementation of
IProxyCreationListener for remote resources.Detector for revealing potential file renames that may have occurred in
IStorageProviderAccessor.DiffSide.SOURCE or
IStorageProviderAccessor.DiffSide.REMOTE in the context of a Subscriber.Utility class that provides a few static methods useful for resolving.
Event that indicates that a resource that should be part of a dependency graph has been found.
A representation of the model object 'Resource Attachment Change'.
Search for
ResourceAttachmentChange conflicts.Search conflicts for
ResourceAttachmentChange of kind DifferenceKind.ADD.Search conflicts for
ResourceAttachmentChange of kind DifferenceKind.CHANGE.Search conflicts for
ResourceAttachmentChange of kind DifferenceKind.DELETE.Search conflicts for
ResourceAttachmentChange of kind DifferenceKind.MOVE.An implementation of the model object 'Resource Attachment Change'.
This is the item provider adapter for a
ResourceAttachmentChange object.Specialized
ResourceAttachmentChangeItemProvider returning nice output for ResourceAttachmentChangeItemProviderSpec.getText(Object)
and ResourceAttachmentChangeItemProviderSpec.getImage(Object).This specific implementation of
AbstractMerger will be used to merge resource attachment changes.A specific
MergeViewerItem for ResourceAttachmentChange.Legacy Provider to keep backward compatibility with
ResourceAttachmentChangeMergeViewerItem.This specialization of the
ResourceAttachmentChangeImpl class allows us to define the derived
features and operations implementations.This adapter is supposed to be installed on a
Comparison's ResourceSets and their
Resources to react to content changes.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.
Class providing facilities to schedule computations and hide as much as possible the multi-threaded
complexity.
A specific
IAccessorFactory for
ResourceAttachmentChange objects.A specific
IResourceContentsAccessor for ResourceAttachmentChange objects.An event indicating that a resource dependency is found.
The default implementation of the
IResourceDependencyProvider.The default implementation of the
IResourceDependencyProvider.The default implementation of the
IResourceDependencyRemoteResolver.A representation of the model object 'Resource Location Change'.
An implementation of the model object 'Resource Location Change'.
This is the item provider adapter for a
ResourceLocationChange object.Specialized
ResourceLocationChangeItemProvider returning nice output for ResourceLocationChangeItemProviderSpec.getText(Object)
and ResourceLocationChangeItemProviderSpec.getImage(Object).Deprecated.
ResourceLocationChanges have been replaced by
ResourceAttachmentChanges of kind Move.This specialization of the
ResourceLocationChangeImpl class allows us to define the derived
features and operations implementations.Event indicating that model resources have been removed, which requires updating the graph of dependencies
between model resources.
Resgistry of
IResourceSetHook.Listener that fill a
ResourceSetHookRegistry.A specific
IStreamContentAccessor
for resources.This class will be used to provide various utilities aimed at NotLoadedFragment manipulation.
This class will be used to provide various utilities aimed at IResource manipulation.
Allows access to the underlying IResourceVariant's storage.
This action will reveal in the StructureMergeViewer all other differences conflicting with the currently
selected one.
This
URIConverter will be used in order to fetch remote content instead of local content when
loading resources.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.
A safe
AdapterFactoryItemDelegator.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.Action that manages the save of the comparison model.
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.
Action that manages the selection of a difference.
This class is responsible for computing similarities between two text contents and deciding whether they
are close enough to be considered a rename.
A specific
IAccessorFactory for
mono-valued structural feature objects.A specific
AbstractStructuralFeatureAccessor for mono-valued structural feature objects.A
IModelUpdateStrategy for single-valued EAttributes.This will allow us to remember the storage path that allowed us to load a given resource.
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.
Mostly copied from org.eclipse.team.internal.ui.StorageTypedElement.
This implementation of an URI converter will keep track of the storages from which it created input
streams.
A
StrategyResourceMatcher will be used to match two or three Resources together; depending
on whether we are doing a two or three way comparison.This implementation of IStorage simply wraps a stream content accessor.
A
ITypedElement that can be used as input of TextMergeViewer.A specific
IAccessorFactory for
string-typed AttributeChange objects.Utility class for
Strings objects.This will be used by the structure viewer to filter out its list of differences according to a number of
provided predicates.
This class will be used by the EMF Compare UI to group differences together in the structural differences
tree viewer.
A custom Iterable that will iterate over the Match->submatch tree of a given Match.
A custom TreeIterator that will iterate over the Match->submatch tree.
This class is used for information flow between
SubscriberProviderRegistryListener and
SubscriberProviderRegistry and managing the creation of ISubscriberProvider instances.The registry managing the registered subscriber provider extension point information.
This listener will react to changes against the subscriber provider extension point, allowing us to be in
sync with plugin activation and deactivation.
This is used by our synchronization model to access the innards of Team's
Subscribers.Utility class for running operation in the UI-Thread if not already within it.
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.
A thread-safe implementation of a ResourceSet that will prevent loading of resources unless explicitly
demanded through
SynchronizedResourceSet.loadResource(URI).Dialog used to ask user synchronization behavior.
A
IViewerCreator that creates TableContentMergeViewer.A concrete implementation of
AbstractTableOrTreeMergeViewer for TableViewer.
A filter used by default that rejects all 'technical' differences.
A highly specialized implementation of a compare input that uses
text
input data to manage the information about the ancestor, left, and right.An encapsulation of information about the three sides of a
TextFallbackCompareInput.A specialized implementation of a compare input label provider.
A highly specialized implementation of a text merge viewer.
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.This implementation of a
IDifferenceGroupProvider will be used to
group the differences by their side : left, right and conflicts.Specialized
BasicDifferenceGroupImpl for Conflicts.Three-way differencing utility for plain text.
SuperClass of factories that need to access tooltips labels.
Store constant used to display or not a trace.
ICompareCommandStack implementation that will delegate to two given command stacks; one for each
side of the comparison.An
IMergeViewerContentProvider that delegates getXXXImage(Object) and
getXXXText() to a CompareConfiguration.A
IViewerCreator that creates TreeContentMergeViewer.Label Provider for
IMergeViewerItems.A specific implementation of
TreeItemProviderAdapterFactory.A concrete implementation of
AbstractTableOrTreeMergeViewer for TreeViewer.ContentProvider for
IMergeViewerItems which uses their 'left', 'right' and 'ancestor' sides in
combination with the given AdapterFactory to create the children and parent
IMergeViewerItems.Provides labels for the content viewer pane.
An implementation of the model object 'Node'.
A specific implementation of
TreeNodeItemProvider.Constants used by org.eclipse.emf.compare.rcp.ui.contentmergeviewer.accessor.legacy.ITypedElement
implementations.
A specific implementation of
AbstractTypedElementAdapter for notifiers.An undo action is implemented by using the
CommandStack.This class is able to measure similarity between "URI like" strings, basically strings separated by "/".
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.This can be used to tell EMF Compare which strategy should be used when matching the EObjects as regards
the identifier.
A
LabelContentViewer in case of a comparison with no differences.Provide the weight to consider while comparing EObjects by their content.
Wrapper describing the given weight provider.
Registry of weight provider descriptors.
A simple implementation of
WeightProvider.Descriptor that will delegate its method implementation
to values given to its constructor.Describes an extension as contributed to the "org.eclipse.emf.compare.rcp.weightProvider" extension point.
This will contain all of the EMF Compare Weight Providers Descriptors.
Listener for contributions to the match engine extension.
This class is not intended to be used outside of its package.
A
IItemDescriptor that wrap one instance of an item
and return the same item each time.
AdapterFactoryItemDelegatorinstead.