Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.eclipse.team.core.variants
Class ThreeWaySynchronizer

    java.lang.Object
      org.eclipse.team.core.variants.ThreeWaySynchronizer

All Implemented Interfaces:
  org.eclipse.team.internal.core.subscribers.BatchingLock.IFlushOperation

public class ThreeWaySynchronizer
extends Object
implements org.eclipse.team.internal.core.subscribers.BatchingLock.IFlushOperation

This class manages the synchronization between local resources and their corresponding resource variants. It provides the following:

- Three way synchronization (set base, set remote, ignored)
- Resource traversal (members)
- Change events and event batching (run)
- Thread-safety

Since:
  3.0

Constructor Summary
`ThreeWaySynchronizer(QualifiedName name)` Create a three-way synchronizer that uses a persistant byte store with the given qualified name as its unique identifier.
`ThreeWaySynchronizer(ResourceVariantByteStore store)` Create a three-way synchronizer that uses the given byte store as its underlying byte cache.

Method Summary
`void` | `addListener(ISynchronizerChangeListener listener)` Adds a listener to this synchronizer.
`void` | `flush(org.eclipse.team.internal.core.subscribers.BatchingLock.ThreadInfo info, IProgressMonitor monitor)`
`void` | `flush(IResource resource, int depth)` Flush any cached bytes for the given resource to the depth specified.
`byte[]` | `getBaseBytes(IResource resource)` Return the base bytes that are cached for the given resource or `null` if no base is cached.
`byte[]` | `getRemoteBytes(IResource resource)` Return the remote bytes that are cached for the given resource or `null` if no remote is cached.
`boolean` | `hasSyncBytes(IResource resource)` Return whether the given resource has sync bytes in the synchronizer.
`boolean` | `isIgnored(IResource resource)` Returns whether the resource has been marked as ignored using `setIgnored(IResource)`.
`boolean` | `isLocallyModified(IResource resource)` Return whether the local resource has been modified since the last time the base bytes were set.
`IResource[]` | `members(IResource resource)` Return the members of the local resource that either have sync bytes or exist locally and are not ignored.
`void` | `removeListener(ISynchronizerChangeListener listener)` Removes a listener previously registered with this synchronizer.
`boolean` | `removeRemoteBytes(IResource resource)` Remove the remote bytes associated with the resource.
`void` | `run(IResource resourceRule, IWorkspaceRunnable runnable, IProgressMonitor monitor)` Perform multiple sync state modifications and fire only a single change notification at the end.
`void` | `setBaseBytes(IResource resource, byte[] baseBytes)` Set the base bytes for the given resource.
`void` | `setIgnored(IResource resource)` Mark the resource as being ignored.
`boolean` | `setRemoteBytes(IResource resource, byte[] remoteBytes)` Set the remote bytes for the given resource.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ThreeWaySynchronizer

    public ThreeWaySynchronizer(QualifiedName name)

  Create a three-way synchronizer that uses a persistant byte store with the given qualified name as its unique identifier.

Parameters:
  `name` - the unique identifier for the persistant store

### ThreeWaySynchronizer

    public ThreeWaySynchronizer(ResourceVariantByteStore store)

  Create a three-way synchronizer that uses the given byte store as its underlying byte cache.

Parameters:
  `store` - the byte store this synchronizer uses to cache its bytes

Method Detail

### addListener

    public void addListener(ISynchronizerChangeListener listener)

  Adds a listener to this synchronizer. Listeners will be notified when the synchronization state of a resource changes. Listeners are not notified when files are modified locally. Clients can make use of the `IResource` delta mechanism if they need to know about local modifications. Has no effect if an identical listener is already registered.

  Team resource change listeners are informed about state changes that affect the resources supervised by this subscriber.

  Parameters:
    `listener` - a synchronizer change listener

### removeListener

    public void removeListener(ISynchronizerChangeListener listener)

  Removes a listener previously registered with this synchronizer. Has no affect if an identical listener is not registered.

  Parameters:
    `listener` - a synchronizer change listener

### getBaseBytes

    public byte[] getBaseBytes(IResource resource)
                        throws TeamException

  Return the base bytes that are cached for the given resource or `null` if no base is cached. The returned bytes should uniquely identify the resource variant that is the base for the given local resource.

  Parameters:
    `resource` - the resource
  Returns:
    the base bytes cached with the resource or `null`
  Throws:
    `TeamException`

### setBaseBytes

    public void setBaseBytes(IResource resource,
                             byte[] baseBytes)
                      throws TeamException

  Set the base bytes for the given resource. The provided bytes should encode enough information to uniquely identify (and possibly recreate) the resource variant that is the base for the given local resource. In essence, setting the base bytes is equivalent to marking the file as in-sync. As such, setting the base bytes will also set the remote bytes and mark the file as clean (i.e. having no outgoing changes).

  Parameters:
    `resource` - the resource
    `baseBytes` - the base bytes that identify the base resource variant
  Throws:
    `TeamException`

### isLocallyModified

    public boolean isLocallyModified(IResource resource)
                              throws TeamException

  Return whether the local resource has been modified since the last time the base bytes were set. This method will return `false` for ignored resources and `true` for non-existant resources that have base bytes cached.

  Parameters:
    `resource` - the resource
  Returns:
    `true` if the resource has been modified since the last time the base bytes were set.
  Throws:
    `TeamException`

### getRemoteBytes

    public byte[] getRemoteBytes(IResource resource)
                          throws TeamException

  Return the remote bytes that are cached for the given resource or `null` if no remote is cached. The returned bytes should uniquely identify the resource variant that is the remote for the given local resource.

  Parameters:
    `resource` - the resource
  Returns:
    the remote bytes cached with the resource or `null`
  Throws:
    `TeamException`

### setRemoteBytes

    public boolean setRemoteBytes(IResource resource,
                                  byte[] remoteBytes)
                           throws TeamException

  Set the remote bytes for the given resource. The provided bytes should encode enough information to uniquely identify (and possibly recreate) the resource variant that is the remote for the given local resource. If the remote for a resource no longer exists, `removeRemoteBytes(IResource)` should be called.

  Parameters:
    `resource` - the resource
    `remoteBytes` - the base bytes that identify the remote resource variant
  Returns:
    `true` if the remote bytes changed as a result of the set
  Throws:
    `TeamException`

### removeRemoteBytes

    public boolean removeRemoteBytes(IResource resource)
                              throws TeamException

  Remove the remote bytes associated with the resource. This is typically done when the corresponding remote resource variant no longer exists.

  Parameters:
    `resource` - the resource
  Returns:
    `true` if the remote bytes changed as a result of the removal
  Throws:
    `TeamException`

### hasSyncBytes

    public boolean hasSyncBytes(IResource resource)
                         throws TeamException

  Return whether the given resource has sync bytes in the synchronizer.

  Parameters:
    `resource` - the local resource
  Returns:
    whether there are sync bytes cached for the local resources.
  Throws:
    `TeamException`

### isIgnored

    public boolean isIgnored(IResource resource)
                      throws TeamException

  Returns whether the resource has been marked as ignored using `setIgnored(IResource)`.

  Parameters:
    `resource` - the resource
  Returns:
    `true` if the resource is ignored.
  Throws:
    `TeamException`

### setIgnored

    public void setIgnored(IResource resource)
                    throws TeamException

  Mark the resource as being ignored. Ignored resources are not returned by the `members` method, are never dirty (see `isLocallyModified`) and do not have base or remote bytes cahced for them.

  Parameters:
    `resource` - the resource to be ignored
  Throws:
    `TeamException`

### members

    public IResource[] members(IResource resource)
                        throws TeamException

  Return the members of the local resource that either have sync bytes or exist locally and are not ignored.

  Parameters:
    `resource` - the local resource
  Returns:
    the children of the local resource that have cached sync bytes or are not ignored
  Throws:
    `TeamException`

### flush

    public void flush(IResource resource,
                      int depth)
               throws TeamException

  Flush any cached bytes for the given resource to the depth specified.

  Parameters:
    `resource` - the resource
    `depth` - the depth of the flush (one of `IResource.DEPTH_ZERO`, `IResource.DEPTH_ONE`, or `IResource.DEPTH_INFINITE`)
  Throws:
    `TeamException`

### run

    public void run(IResource resourceRule,
                    IWorkspaceRunnable runnable,
                    IProgressMonitor monitor)
             throws TeamException

  Perform multiple sync state modifications and fire only a single change notification at the end.

  Parameters:
    `resourceRule` - the scheduling rule that encompasses all modifications
    `runnable` - the runnable that performs the sync state modifications
    `monitor` - a progress monitor
  Throws:
    `TeamException`

### flush

    public void flush(org.eclipse.team.internal.core.subscribers.BatchingLock.ThreadInfo info,
                      IProgressMonitor monitor)
               throws TeamException

  Specified by:
    `flush` in interface `org.eclipse.team.internal.core.subscribers.BatchingLock.IFlushOperation`
  Throws:
    `TeamException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Guidelines for using Eclipse APIs.

Copyright (c) IBM Corp. and others 2000, 2004. All rights reserved.