Interface ISynchronizationContext
- All Known Subinterfaces:
IMergeContext
- All Known Implementing Classes:
MergeContext,SubscriberMergeContext,SynchronizationContext
The scope of the context is defined when the context is created. The creator of the scope may affect changes on the scope which will result in property change events from the scope and may result in change events from the diff tree. Clients should note that it is possible that a change in the scope will result in new resources with differences being covered by the scope but not result in a change event from the diff tree. This can occur because the set may already have contained a diff for the resource with the understanding that the client would have ignored it. Consequently, clients should listen to both sources in order to guarantee that they update any dependent state appropriately.
The diff tree associated with this context may be updated asynchronously in
response to calls to any method of this context (e.g. refresh methods) that
may result in changes in the synchronization state of resources. It may also
get updated as a result of changes triggered from other sources. Hence, the
callback from the diff tree to report changes may occur in the same thread as
the method call or asynchronously in a separate thread, regardless of who
triggered the refresh. Clients of this method (and any other asynchronous
method on this context) may determine if all changes have been collected
using IJobManager.find(Object) using this context as the
family argument in order to determine if there are any jobs
running that are populating the diff tree. Clients may also call
IJobManager.join(Object, IProgressMonitor) if they wish to wait until
all background handlers related to this context are finished.
- Since:
- 3.2
- See Also:
- Restriction:
- This interface is not intended to be implemented by clients.
They should subclass
SynchronizationContextor one of its subclasses instead.
-
Field Summary
Fields -
Method Summary
Modifier and TypeMethodDescriptionvoiddispose()Dispose of the synchronization context and the cache of the context.getCache()Return the cache associated with this synchronization context.Return a tree that containsIDiffentries for resources that are out-of-sync.getScope()Return the input that defined the scope of this synchronization context.intgetType()Return the synchronization type.voidrefresh(ResourceMapping[] mappings, IProgressMonitor monitor) Refresh the portion of the context related to the given resource mappings.voidrefresh(ResourceTraversal[] traversals, int flags, IProgressMonitor monitor) Refresh the context in order to update the diff tree returned bygetDiffTree()to include the latest synchronization state for the resources.
-
Field Details
-
TWO_WAY
static final int TWO_WAYSynchronization type constant that indicates that context is a two-way synchronization.- See Also:
-
THREE_WAY
static final int THREE_WAYSynchronization type constant that indicates that context is a three-way synchronization.- See Also:
-
-
Method Details
-
getScope
ISynchronizationScope getScope()Return the input that defined the scope of this synchronization context. The input determines the set of resources to which the context applies. Changes in the input may result in changes to the sync-info available in the tree of this context.- Returns:
- the input that defined the scope of this synchronization context.
-
getDiffTree
IResourceDiffTree getDiffTree()Return a tree that containsIDiffentries for resources that are out-of-sync. The tree will contain entries for any out-of-sync resources that are within the scope of this context. The tree may include entries for additional resources, which should be ignored by the client. Clients can test for inclusion using the methodISynchronizationScope.contains(IResource).The returned
IResourceDiffTreewill be homogeneous and contain eitherIResourceDifforIThreeWayDiffinstances. AnyIThreeWayDiffcontained in the returned tree will containIResourceDiffinstances as the local and remote changes. This interface also has several helper methods for handling entries contained in the returned diff tree.- Returns:
- a tree that contains an entry for any resources that are out-of-sync.
- See Also:
-
getType
int getType()Return the synchronization type. A type ofTWO_WAYindicates that the synchronization information associated with the context will also be two-wayIDiffinstances (i.e. there is only a remote but no base involved in the comparison used to determine the synchronization state of resources. A type ofTHREE_WAYindicates that the synchronization information will be three-wayIThreeWayDiffinstances.- Returns:
- the type of synchronization information available in the context
- See Also:
-
getCache
ICache getCache()Return the cache associated with this synchronization context. The cache is maintained for the lifetime of this context and is disposed when the the context is disposed. It can be used by clients to cache model state related to the context so that it can be maintained for the life of the operation to which the context applies.- Returns:
- the cache associated with this synchronization context
-
dispose
void dispose()Dispose of the synchronization context and the cache of the context. This method should be invoked by clients when the context is no longer needed. -
refresh
void refresh(ResourceTraversal[] traversals, int flags, IProgressMonitor monitor) throws CoreException Refresh the context in order to update the diff tree returned bygetDiffTree()to include the latest synchronization state for the resources. Any changes will be reported through the change listeners registered with the diff tree of this context.Changes to the diff tree may be triggered by a call to this method or by a refresh triggered by some other source. Hence, the callback from the diff tree to report changes may occur in the same thread as the refresh or asynchronously in a separate thread, regardless of who triggered the refresh.
- Parameters:
traversals- the resource traversals which indicate which resources are to be refreshedflags- additional refresh behavior. For instance, ifRemoteResourceMappingContext.FILE_CONTENTS_REQUIREDis one of the flags, this indicates that the client will be accessing the contents of the files covered by the traversals.NONEshould be used when no additional behavior is requiredmonitor- a progress monitor, ornullif progress reporting is not desired- Throws:
CoreException- if the refresh fails. Reasons include:- The server could not be contacted for some reason (e.g. the context in which the operation is being called must be short running). The status code will be SERVER_CONTACT_PROHIBITED.
- See Also:
-
refresh
Refresh the portion of the context related to the given resource mappings. The provided mappings must be within the scope of this context. Refreshing mappings may result in additional resources being added to the scope of this context. If new resources are included in the scope, a property change event will be fired from the scope. If the synchronization state of any of the resources covered by the mapping change, a change event will be fired from the diff tree of this context.Changes to the diff tree may be triggered by a call to this method or by a refresh triggered by some other source. Hence, the callback from the diff tree to report changes may occur in the same thread as the refresh or asynchronously in a separate thread, regardless of who triggered the refresh.
- Parameters:
mappings- the mappings to be refreshedmonitor- a progress monitor- Throws:
CoreException- if errors occur
-