Eclipse Platform
Release 3.2

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.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(java.lang.reflect.InvocationTargetException e)
          Return a TeamException for the given exception.
 

Methods in org.eclipse.team.core that throw TeamException
 IProject[] ProjectSetCapability.addToWorkspace(java.lang.String[] referenceStrings, ProjectSetSerializationContext context, IProgressMonitor monitor)
          For every String in referenceStrings, load the corresponding project into the workspace.
 IProject[] IProjectSetSerializer.addToWorkspace(java.lang.String[] referenceStrings, java.lang.String filename, java.lang.Object context, IProgressMonitor monitor)
          Deprecated. For every String in referenceStrings, create in the workspace a corresponding IProject.
 java.lang.String[] IProjectSetSerializer.asReference(IProject[] providerProjects, java.lang.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.
 java.lang.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, java.lang.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[] ThreeWayRemoteTree.collectChanges(IResource local, IResourceVariant remote, int depth, IProgressMonitor monitor)
           
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[] 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 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.
 boolean SessionResourceVariantByteStore.deleteBytes(IResource 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(org.eclipse.team.internal.core.subscribers.BatchingLock.ThreadInfo info, IProgressMonitor monitor)
           
 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 PersistantResourceVariantByteStore.flushBytes(IResource resource, int depth)
           
 boolean SessionResourceVariantByteStore.flushBytes(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.
 void ResourceVariantTree.flushVariants(IResource resource, int depth)
           
 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[] PersistantResourceVariantByteStore.getBytes(IResource resource)
           
 byte[] SessionResourceVariantByteStore.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  java.io.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 CachedResourceVariant.getStorage(IProgressMonitor monitor)
           
 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).
 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 IResourceVariantTree.hasResourceVariant(IResource resource)
          Return whether the local resource has a variant in this tree.
 boolean ResourceVariantTree.hasResourceVariant(IResource 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).
 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[] IResourceVariantTree.members(IResource resource)
          Returns the members of the local resource that have resource variants in this tree.
abstract  IResource[] ResourceVariantByteStore.members(IResource resource)
          Return the children of the given resource that have resource variants in this tree.
 IResource[] ResourceVariantTreeSubscriber.members(IResource resource)
           
 IResource[] ResourceVariantTree.members(IResource resource)
           
 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[] 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 ResourceVariantTreeSubscriber.refresh(IResource[] resources, int depth, IProgressMonitor monitor)
           
 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.
 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 PersistantResourceVariantByteStore.setBytes(IResource resource, byte[] bytes)
           
 boolean SessionResourceVariantByteStore.setBytes(IResource resource, byte[] bytes)
           
protected  void CachedResourceVariant.setContents(java.io.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.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.2

Guidelines for using Eclipse APIs.

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