Eclipse Platform Release 3.7

## Uses of Class
org.eclipse.team.core.TeamException

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.history: Application programming interfaces for working with history.
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
`IProject[]` `ProjectSetCapability.addToWorkspace(String[] referenceStrings, ProjectSetSerializationContext context, IProgressMonitor monitor)` For every String in `referenceStrings`, load the corresponding project into the workspace.
`IProject[]` `IProjectSetSerializer.addToWorkspace(String[] referenceStrings, String filename, Object context, IProgressMonitor monitor)` Deprecated. For every String in referenceStrings, create in the workspace a corresponding IProject.
`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.
`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[]` `ProjectSetSerializationContext.confirmOverwrite(IProject[] projects)` Given an array of projects that currently exist in the workspace determine which of those projects should be overwritten.
`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.
`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.

Uses of TeamException in org.eclipse.team.core.subscribers

Methods in org.eclipse.team.core.subscribers that throw TeamException
`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 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.
`protected void` `SubscriberResourceMappingContext.refresh(IResource[] resources, int depth, int flags, IProgressMonitor monitor)` Refresh the subscriber and cache the fact that the resources were refreshed by calling the `refreshed` method.
`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.
`void` `Subscriber.refresh(ResourceTraversal[] traversals, IProgressMonitor monitor)` Refresh the subscriber for the given traversals.

Uses of TeamException in org.eclipse.team.core.synchronize

Methods in org.eclipse.team.core.synchronize that throw TeamException
`protected int` `SyncInfo.calculateKind()` Method that is invoked from the `init()` method to calculate the sync kind for this instance of `SyncInfo`.
`void` `SyncInfo.init()` Method that is invoked after instance creation to initialize the sync kind.

Uses of TeamException in org.eclipse.team.core.variants

Methods in org.eclipse.team.core.variants that throw TeamException
`protected IResource[]` `AbstractResourceVariantTree.collectChanges(IResource local, IResourceVariant remote, int depth, IProgressMonitor monitor)` Collect the changes in the remote tree to the specified depth.
`protected IResource[]` `ResourceVariantTree.collectChanges(IResource local, IResourceVariant remote, int depth, IProgressMonitor monitor)`
`protected IResource[]` `ThreeWayRemoteTree.collectChanges(IResource local, IResourceVariant remote, int depth, IProgressMonitor monitor)`
`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.
`abstract boolean` `ResourceVariantByteStore.deleteBytes(IResource resource)` Method called to indicate that it is known that there is no variant associated with the local resource.
`boolean` `SessionResourceVariantByteStore.deleteBytes(IResource resource)`
`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.
`protected abstract void` `CachedResourceVariant.fetchContents(IProgressMonitor monitor)` Method that is invoked when the contents of the resource variant need to be fetched.
`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.
`void` `ThreeWaySynchronizer.flush(IResource resource, int depth)` Flush any cached bytes for the given resource to the depth specified.
`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.
`boolean` `SessionResourceVariantByteStore.flushBytes(IResource resource, int depth)`
`boolean` `PersistantResourceVariantByteStore.flushBytes(IResource resource, int depth)`
`void` `ResourceVariantTree.flushVariants(IResource resource, int depth)`
`void` `IResourceVariantTree.flushVariants(IResource resource, int depth)` Flush any variants in the tree for the given resource to the depth specified.
`byte[]` `ThreeWaySynchronizer.getBaseBytes(IResource resource)` Return the base bytes that are cached for the given resource or `null` if no base is cached.
`abstract byte[]` `ResourceVariantByteStore.getBytes(IResource resource)` Return the bytes for the variant corresponding the given local resource.
`byte[]` `SessionResourceVariantByteStore.getBytes(IResource resource)`
`byte[]` `PersistantResourceVariantByteStore.getBytes(IResource resource)`
`protected byte[]` `ResourceVariantTree.getBytes(IResource local, IResourceVariant remote)` Get the bytes to be stored in the `ResourceVariantByteStore` from the given resource variant.
`protected InputStream` `CachedResourceVariant.getCachedContents()` Return the cached contents for this resource variant or `null` if the contents have not been cached.
`byte[]` `ThreeWaySynchronizer.getRemoteBytes(IResource resource)` Return the remote bytes that are cached for the given resource or `null` if no remote is cached.
`IResourceVariant` `ThreeWayRemoteTree.getResourceVariant(IResource resource)`
`IResourceVariant` `IResourceVariantTree.getResourceVariant(IResource resource)` Return the resource variant corresponding to the local resource.
`abstract IResourceVariant` `ThreeWaySubscriber.getResourceVariant(IResource resource, byte[] bytes)` Create the resource variant for the given local resource from the given bytes.
`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)`
`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.
`boolean` `ResourceVariantTree.hasResourceVariant(IResource resource)`
`boolean` `IResourceVariantTree.hasResourceVariant(IResource resource)` Return whether the local resource has a variant in this tree.
`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)`.
`boolean` `ThreeWaySynchronizer.isLocallyModified(IResource resource)` Return whether the local resource has been modified since the last time the base bytes were set.
`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)`.
`boolean` `PersistantResourceVariantByteStore.isVariantKnown(IResource resource)` Return whether the resource variant state for this resource is known.
`IResource[]` `ResourceVariantTreeSubscriber.members(IResource resource)`
`abstract IResource[]` `ResourceVariantByteStore.members(IResource resource)` Return the children of the given resource that have resource variants in this tree.
`IResource[]` `ResourceVariantTree.members(IResource resource)`
`IResource[]` `IResourceVariantTree.members(IResource resource)` Returns the members of the local resource that have resource variants in this tree.
`IResource[]` `ThreeWaySynchronizer.members(IResource resource)` Return the members of the local resource that either have sync bytes or exist locally and are not ignored.
`IResource[]` `PersistantResourceVariantByteStore.members(IResource resource)`
`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.
`void` `ResourceVariantTreeSubscriber.refresh(IResource[] resources, int depth, IProgressMonitor monitor)`
`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.
`protected IResource[]` `AbstractResourceVariantTree.refresh(IResource resource, int depth, IProgressMonitor monitor)` Helper method invoked from `refresh(IResource[], int, IProgressMonitor monitor)` for each resource.
`boolean` `ThreeWaySynchronizer.removeRemoteBytes(IResource resource)` Remove the remote bytes associated with the resource.
`void` `ResourceVariantByteStore.run(IResource root, IWorkspaceRunnable runnable, IProgressMonitor monitor)` Run the given action which may contain multiple modifications to the byte store.
`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` `PersistantResourceVariantByteStore.run(IResource root, IWorkspaceRunnable runnable, IProgressMonitor monitor)`
`void` `ThreeWaySynchronizer.setBaseBytes(IResource resource, byte[] baseBytes)` Set the base bytes for the given resource.
`abstract boolean` `ResourceVariantByteStore.setBytes(IResource resource, byte[] bytes)` Set the bytes for the variant corresponding the given local resource.
`boolean` `SessionResourceVariantByteStore.setBytes(IResource resource, byte[] bytes)`
`boolean` `PersistantResourceVariantByteStore.setBytes(IResource resource, byte[] bytes)`
`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.
`void` `ThreeWaySynchronizer.setIgnored(IResource resource)` Mark the resource as being ignored.
`boolean` `ThreeWaySynchronizer.setRemoteBytes(IResource resource, byte[] remoteBytes)` Set the remote bytes 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.
`protected boolean` `ResourceVariantTree.setVariant(IResource local, IResourceVariant remote)`

Uses of TeamException in org.eclipse.team.ui.history

Methods in org.eclipse.team.ui.history that throw TeamException
`static ITypedElement` `ElementLocalHistoryPageSource.getPreviousEdition(IFile file, Object element)` Return the previous edition from the local history of the given element located in the given file.

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` `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`.
`void` `ISynchronizeParticipant.prepareCompareInput(ISynchronizeModelElement element, CompareConfiguration configuration, IProgressMonitor monitor)` Prepare the given element and compare configuration for use with a compare editor input.

Eclipse Platform Release 3.7

Guidelines for using Eclipse APIs.

Copyright (c) Eclipse contributors and others 2000, 2011. All rights reserved.