|
Eclipse Platform Release 3.1 |
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use TeamException | |
---|---|
org.eclipse.team.core | Application programming interfaces for defining and working with repository providers. |
org.eclipse.team.core.subscribers | Application programming interfaces for generating and refreshing synchronization state. |
org.eclipse.team.core.synchronize | Application programming interfaces for managing synchronization state. |
org.eclipse.team.core.variants | Application programming interfaces for accessing and managing resource variants. |
org.eclipse.team.ui.synchronize | Contains the team synchronization presentation framework and support for the Synchronize View. |
Uses of TeamException in org.eclipse.team.core |
---|
Methods in org.eclipse.team.core that return TeamException | |
static TeamException |
TeamException.asTeamException(CoreException e)
Return a TeamException for the given exception. |
static TeamException |
TeamException.asTeamException(InvocationTargetException e)
Return a TeamException for the given exception. |
Methods in org.eclipse.team.core that throw TeamException | |
static void |
RepositoryProvider.map(IProject project,
String id)
Instantiate a new RepositoryProvider with concrete class by given providerID and associate it with project. |
static void |
RepositoryProvider.unmap(IProject project)
Disassociates project with the repository provider its currently mapped to. |
IProject[] |
ProjectSetSerializationContext.confirmOverwrite(IProject[] projects)
Given an array of projects that currently exist in the workspace determine which of those projects should be overwritten. |
String[] |
ProjectSetCapability.asReference(IProject[] providerProjects,
ProjectSetSerializationContext context,
IProgressMonitor monitor)
For every project in providerProjects, return an opaque UTF-8 encoded String to act as a reference to that project. |
IProject[] |
ProjectSetCapability.addToWorkspace(String[] referenceStrings,
ProjectSetSerializationContext context,
IProgressMonitor monitor)
For every String in referenceStrings, load the corresponding project into the workspace. |
protected IProject[] |
ProjectSetCapability.confirmOverwrite(ProjectSetSerializationContext context,
IProject[] projects)
Determine if any of the projects already exist and confirm which of those projects are to be overwritten. |
String[] |
IProjectSetSerializer.asReference(IProject[] providerProjects,
Object context,
IProgressMonitor monitor)
Deprecated. For every IProject in providerProjects, return an opaque UTF-8 encoded String to act as a reference to that project. |
IProject[] |
IProjectSetSerializer.addToWorkspace(String[] referenceStrings,
String filename,
Object context,
IProgressMonitor monitor)
Deprecated. For every String in referenceStrings, create in the workspace a corresponding IProject. |
Uses of TeamException in org.eclipse.team.core.subscribers |
---|
Methods in org.eclipse.team.core.subscribers that throw TeamException | |
abstract boolean |
Subscriber.isSupervised(IResource resource)
Returns true if this resource is supervised by this
subscriber. |
abstract IResource[] |
Subscriber.members(IResource resource)
Returns all non-transient member resources of the given resource. |
abstract SyncInfo |
Subscriber.getSyncInfo(IResource resource)
Returns synchronization info for the given resource, or null
if there is no synchronization info because the subscriber does not apply
to this resource.
|
abstract void |
Subscriber.refresh(IResource[] resources,
int depth,
IProgressMonitor monitor)
Refreshes the resource hierarchy from the given resources and their children (to the specified depth) from the corresponding resources in the remote location. |
Uses of TeamException in org.eclipse.team.core.synchronize |
---|
Methods in org.eclipse.team.core.synchronize that throw TeamException | |
void |
SyncInfo.init()
Method that is invoked after instance creation to initialize the sync kind. |
protected int |
SyncInfo.calculateKind()
Method that is invoked from the init() method to calculate
the sync kind for this instance of SyncInfo . |
Uses of TeamException in org.eclipse.team.core.variants |
---|
Methods in org.eclipse.team.core.variants that throw TeamException | |
byte[] |
ThreeWaySynchronizer.getBaseBytes(IResource resource)
Return the base bytes that are cached for the given resource or null if no base is cached. |
void |
ThreeWaySynchronizer.setBaseBytes(IResource resource,
byte[] baseBytes)
Set the base bytes for the given resource. |
boolean |
ThreeWaySynchronizer.isLocallyModified(IResource resource)
Return whether the local resource has been modified since the last time the base bytes were set. |
byte[] |
ThreeWaySynchronizer.getRemoteBytes(IResource resource)
Return the remote bytes that are cached for the given resource or null if no remote is cached. |
boolean |
ThreeWaySynchronizer.setRemoteBytes(IResource resource,
byte[] remoteBytes)
Set the remote bytes for the given resource. |
boolean |
ThreeWaySynchronizer.removeRemoteBytes(IResource resource)
Remove the remote bytes associated with the resource. |
boolean |
ThreeWaySynchronizer.hasSyncBytes(IResource resource)
Return whether the given resource has sync bytes in the synchronizer. |
boolean |
ThreeWaySynchronizer.isIgnored(IResource resource)
Returns whether the resource has been marked as ignored using setIgnored(IResource) . |
void |
ThreeWaySynchronizer.setIgnored(IResource resource)
Mark the resource as being ignored. |
IResource[] |
ThreeWaySynchronizer.members(IResource resource)
Return the members of the local resource that either have sync bytes or exist locally and are not ignored. |
void |
ThreeWaySynchronizer.flush(IResource resource,
int depth)
Flush any cached bytes for the given resource to the depth specified. |
void |
ThreeWaySynchronizer.run(IResource resourceRule,
IWorkspaceRunnable runnable,
IProgressMonitor monitor)
Perform multiple sync state modifications and fire only a single change notification at the end. |
void |
ThreeWaySynchronizer.flush(org.eclipse.team.internal.core.subscribers.BatchingLock.ThreadInfo info,
IProgressMonitor monitor)
|
boolean |
ThreeWaySubscriber.isSupervised(IResource resource)
Returns false for resources that are not children
of a subscriber root, are ignored by the subscriber's synchronizer
or are ignored by the Team.ignoreHist(IResource) . |
abstract IResourceVariant |
ThreeWaySubscriber.getResourceVariant(IResource resource,
byte[] bytes)
Create the resource variant for the given local resource from the given bytes. |
IResourceVariant |
ThreeWayRemoteTree.getResourceVariant(IResource resource)
|
protected IResource[] |
ThreeWayRemoteTree.collectChanges(IResource local,
IResourceVariant remote,
int depth,
IProgressMonitor monitor)
|
boolean |
SessionResourceVariantByteStore.deleteBytes(IResource resource)
|
boolean |
SessionResourceVariantByteStore.flushBytes(IResource resource,
int depth)
|
byte[] |
SessionResourceVariantByteStore.getBytes(IResource resource)
|
boolean |
SessionResourceVariantByteStore.setBytes(IResource resource,
byte[] bytes)
|
SyncInfo |
ResourceVariantTreeSubscriber.getSyncInfo(IResource resource)
|
protected SyncInfo |
ResourceVariantTreeSubscriber.getSyncInfo(IResource local,
IResourceVariant base,
IResourceVariant remote)
Method that creates an instance of SyncInfo for the provided local, base and remote resource variants. |
IResource[] |
ResourceVariantTreeSubscriber.members(IResource resource)
|
void |
ResourceVariantTreeSubscriber.refresh(IResource[] resources,
int depth,
IProgressMonitor monitor)
|
IResource[] |
ResourceVariantTree.members(IResource resource)
|
boolean |
ResourceVariantTree.hasResourceVariant(IResource resource)
|
void |
ResourceVariantTree.flushVariants(IResource resource,
int depth)
|
protected boolean |
ResourceVariantTree.setVariant(IResource local,
IResourceVariant remote)
|
protected byte[] |
ResourceVariantTree.getBytes(IResource local,
IResourceVariant remote)
Get the bytes to be stored in the ResourceVariantByteStore
from the given resource variant. |
protected IResource[] |
ResourceVariantTree.collectChanges(IResource local,
IResourceVariant remote,
int depth,
IProgressMonitor monitor)
|
abstract byte[] |
ResourceVariantByteStore.getBytes(IResource resource)
Return the bytes for the variant corresponding the given local resource. |
abstract boolean |
ResourceVariantByteStore.setBytes(IResource resource,
byte[] bytes)
Set the bytes for the variant corresponding the given local resource. |
abstract boolean |
ResourceVariantByteStore.flushBytes(IResource resource,
int depth)
Remove the bytes from the tree for the resource variants corresponding to the given local resource and its descendants to the given depth. |
abstract boolean |
ResourceVariantByteStore.deleteBytes(IResource resource)
Method called to indicate that it is known that there is no variant associated with the local resource. |
abstract IResource[] |
ResourceVariantByteStore.members(IResource resource)
Return the children of the given resource that have resource variants in this tree. |
void |
ResourceVariantByteStore.run(IResource root,
IWorkspaceRunnable runnable,
IProgressMonitor monitor)
Run the given action which may contain multiple modifications to the byte store. |
byte[] |
PersistantResourceVariantByteStore.getBytes(IResource resource)
|
boolean |
PersistantResourceVariantByteStore.setBytes(IResource resource,
byte[] bytes)
|
boolean |
PersistantResourceVariantByteStore.flushBytes(IResource resource,
int depth)
|
boolean |
PersistantResourceVariantByteStore.isVariantKnown(IResource resource)
Return whether the resource variant state for this resource is known. |
boolean |
PersistantResourceVariantByteStore.deleteBytes(IResource resource)
This method should be invoked by a client to indicate that it is known that there is no remote resource associated with the local resource. |
IResource[] |
PersistantResourceVariantByteStore.members(IResource resource)
|
void |
PersistantResourceVariantByteStore.run(IResource root,
IWorkspaceRunnable runnable,
IProgressMonitor monitor)
|
IResource[] |
IResourceVariantTree.members(IResource resource)
Returns the members of the local resource that have resource variants in this tree. |
IResourceVariant |
IResourceVariantTree.getResourceVariant(IResource resource)
Return the resource variant corresponding to the local resource. |
boolean |
IResourceVariantTree.hasResourceVariant(IResource resource)
Return whether the local resource has a variant in this tree. |
IResource[] |
IResourceVariantTree.refresh(IResource[] resources,
int depth,
IProgressMonitor monitor)
Refreshes the resource variant tree for the specified resources and possibly their descendants, depending on the depth. |
void |
IResourceVariantTree.flushVariants(IResource resource,
int depth)
Flush any variants in the tree for the given resource to the depth specified. |
IStorage |
IResourceVariant.getStorage(IProgressMonitor monitor)
Return an instance of IStorage or null if the remote resource
does not have contents (i.e. is a folder). |
IStorage |
CachedResourceVariant.getStorage(IProgressMonitor monitor)
|
protected abstract void |
CachedResourceVariant.fetchContents(IProgressMonitor monitor)
Method that is invoked when the contents of the resource variant need to be fetched. |
protected void |
CachedResourceVariant.setContents(InputStream stream,
IProgressMonitor monitor)
This method should be invoked by subclasses from within their fetchContents
method in order to cache the contents for this resource variant.
|
protected InputStream |
CachedResourceVariant.getCachedContents()
Return the cached contents for this resource variant or null
if the contents have not been cached.
|
IResource[] |
AbstractResourceVariantTree.refresh(IResource[] resources,
int depth,
IProgressMonitor monitor)
Refreshes the resource variant tree for the specified resources and possibly their descendants, depending on the depth. |
protected IResource[] |
AbstractResourceVariantTree.refresh(IResource resource,
int depth,
IProgressMonitor monitor)
Helper method invoked from refresh(IResource[], int, IProgressMonitor monitor)
for each resource. |
protected IResource[] |
AbstractResourceVariantTree.collectChanges(IResource local,
IResourceVariant remote,
int depth,
IProgressMonitor monitor)
Collect the changes in the remote tree to the specified depth. |
protected abstract IResourceVariant[] |
AbstractResourceVariantTree.fetchMembers(IResourceVariant variant,
IProgressMonitor progress)
Fetch the members of the given resource variant handle. |
protected abstract IResourceVariant |
AbstractResourceVariantTree.fetchVariant(IResource resource,
int depth,
IProgressMonitor monitor)
Fetch the resource variant corresponding to the given resource. |
protected IResource[] |
AbstractResourceVariantTree.collectedMembers(IResource local,
IResource[] members)
Method that is invoked during collection to let subclasses know which members were collected for the given resource. |
protected abstract boolean |
AbstractResourceVariantTree.setVariant(IResource local,
IResourceVariant remote)
Set the variant associated with the local resource to the newly fetched resource variant. |
Uses of TeamException in org.eclipse.team.ui.synchronize |
---|
Methods in org.eclipse.team.ui.synchronize that throw TeamException | |
ISynchronizeParticipant |
ISynchronizeParticipantReference.getParticipant()
Returns the participant referenced by this handle. |
void |
ISynchronizeParticipant.prepareCompareInput(ISynchronizeModelElement element,
CompareConfiguration configuration,
IProgressMonitor monitor)
Prepare the given element and compare configuration for use with a compare editor input. |
void |
AbstractSynchronizeParticipant.prepareCompareInput(ISynchronizeModelElement element,
CompareConfiguration config,
IProgressMonitor monitor)
Default implementation will update the labels in the given configuration using information from the provided element if it adapts to SyncInfo .
|
|
Eclipse Platform Release 3.1 |
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Guidelines for using Eclipse APIs.
Copyright (c) IBM Corp. and others 2000, 2005. All rights reserved.