org.eclipse.team.cvs.core_3.3.400.I20110510-0800

;
          }
        }
      });
      autoShareJob.setSystem(true);
      autoShareJob.setPriority(20);
      
      autoShareJob.setRule(ResourcesPlugin.getWorkspace().getRoot());
    }
    return autoShareJob;
  }
  
  public boolean supportsProjectSetImportRelocation()
  {
    return false;
  }
  
  public ProjectSetCapability getProjectSetCapability()
  {
    return new CVSProjectSetCapability();
  }
  
  public void metaFilesDetected(IProject project, IContainer[] containers)
  {
    for (int i = 0; i < containers.length; i++)
    {
      IContainer container = containers[i];
      IContainer cvsDir = null;
      if (container.getName().equals("CVS"))
      {
        cvsDir = container;
      }
      else
      {
        IResource resource = container.findMember("CVS");
        if (resource.getType() != 1) {
          cvsDir = (IContainer)resource;
        }
      }
      try
      {
        if ((cvsDir != null) && (!cvsDir.isTeamPrivateMember())) {
          cvsDir.setTeamPrivateMember(true);
        }
      }
      catch (CoreException e)
      {
        TeamPlugin.log(4, "Could not flag meta-files as team-private for " + cvsDir.getFullPath(), e);
      }
    }
    if (CVSProviderPlugin.getPlugin().isAutoshareOnImport()) {
      getAutoShareJob().share(project);
    }
  }
  
  public Subscriber getSubscriber()
  {
    return CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber();
  }
  
  public Object getAdapter(Class adapter)
  {
    if ((adapter == ActiveChangeSetManager.class) || (adapter == IChangeGroupingRequestor.class)) {
      return CVSProviderPlugin.getPlugin().getChangeSetManager();
    }
    return Platform.getAdapterManager().getAdapter(this, adapter);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.CVSTeamProviderType
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.variants.ResourceVariantByteStore;
import org.eclipse.team.internal.ccvs.core.syncinfo.CVSResourceVariantTree;

class CVSWorkspaceSubscriber$1
  extends CVSResourceVariantTree
{
  final CVSWorkspaceSubscriber this$0;
  
  CVSWorkspaceSubscriber$1(CVSWorkspaceSubscriber paramCVSWorkspaceSubscriber, ResourceVariantByteStore $anonymous0, CVSTag $anonymous1, boolean $anonymous2)
  {
    super($anonymous0, $anonymous1, $anonymous2);this$0 = paramCVSWorkspaceSubscriber;
  }
  
  public IResource[] refresh(IResource[] resources, int depth, IProgressMonitor monitor)
    throws TeamException
  {
    try
    {
      monitor.beginTask(null, 100);
      return new IResource[0];
    }
    finally
    {
      monitor.done();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.CVSWorkspaceSubscriber.1
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.team.core.variants.ResourceVariantByteStore;
import org.eclipse.team.internal.ccvs.core.syncinfo.CVSResourceVariantTree;

class CVSWorkspaceSubscriber$2
  extends CVSResourceVariantTree
{
  final CVSWorkspaceSubscriber this$0;
  
  CVSWorkspaceSubscriber$2(CVSWorkspaceSubscriber paramCVSWorkspaceSubscriber, ResourceVariantByteStore $anonymous0, CVSTag $anonymous1, boolean $anonymous2)
  {
    super($anonymous0, $anonymous1, $anonymous2);this$0 = paramCVSWorkspaceSubscriber;
  }
  
  public boolean isCacheFileContentsHint()
  {
    return this$0.getCacheFileContentsHint();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.CVSWorkspaceSubscriber.2
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.TeamStatus;
import org.eclipse.team.core.synchronize.SyncInfo;
import org.eclipse.team.core.synchronize.SyncInfoSet;

class CVSWorkspaceSubscriber$3
  implements IResourceVisitor
{
  final CVSWorkspaceSubscriber this$0;
  private final IProgressMonitor val$monitor;
  private final SyncInfoSet val$set;
  
  CVSWorkspaceSubscriber$3(CVSWorkspaceSubscriber paramCVSWorkspaceSubscriber, IProgressMonitor paramIProgressMonitor, SyncInfoSet paramSyncInfoSet)
  {
    this$0 = paramCVSWorkspaceSubscriber;val$monitor = paramIProgressMonitor;val$set = paramSyncInfoSet;
  }
  
  public boolean visit(IResource innerResource)
    throws CoreException
  {
    try
    {
      Policy.checkCanceled(val$monitor);
      if (innerResource.getType() != 1) {
        val$monitor.subTask(NLS.bind(CVSMessages.CVSWorkspaceSubscriber_1, new String[] { innerResource.getFullPath().toString() }));
      }
      if (this$0.isOutOfSync(innerResource, val$monitor))
      {
        SyncInfo info = this$0.getSyncInfo(innerResource);
        if ((info != null) && (info.getKind() != 0)) {
          val$set.add(info);
        }
      }
    }
    catch (TeamException e)
    {
      val$set.addError(new TeamStatus(
        4, "org.eclipse.team.cvs.core", 1, 
        NLS.bind(CVSMessages.CVSWorkspaceSubscriber_2, new String[] { innerResource.getFullPath().toString(), e.getMessage() }), e, innerResource));
    }
    return true;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.CVSWorkspaceSubscriber.3
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.osgi.util.NLS;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.TeamStatus;
import org.eclipse.team.core.diff.IDiff;
import org.eclipse.team.core.diff.IThreeWayDiff;
import org.eclipse.team.core.diff.ITwoWayDiff;
import org.eclipse.team.core.subscribers.SubscriberChangeEvent;
import org.eclipse.team.core.subscribers.SubscriberResourceMappingContext;
import org.eclipse.team.core.synchronize.SyncInfo;
import org.eclipse.team.core.synchronize.SyncInfoSet;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.team.core.variants.IResourceVariantTree;
import org.eclipse.team.core.variants.PersistantResourceVariantByteStore;
import org.eclipse.team.core.variants.ResourceVariantByteStore;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.core.resources.EclipseSynchronizer;
import org.eclipse.team.internal.ccvs.core.syncinfo.CVSBaseResourceVariantTree;
import org.eclipse.team.internal.ccvs.core.syncinfo.CVSDescendantResourceVariantByteStore;
import org.eclipse.team.internal.ccvs.core.syncinfo.CVSResourceVariantTree;
import org.eclipse.team.internal.ccvs.core.util.ResourceStateChangeListeners;
import org.eclipse.team.internal.core.subscribers.ActiveChangeSetManager;

public class CVSWorkspaceSubscriber
  extends CVSSyncTreeSubscriber
  implements IResourceStateChangeListener
{
  private CVSResourceVariantTree baseTree;
  private CVSResourceVariantTree remoteTree;
  private static final String REMOTE_RESOURCE_KEY = "remote-resource-key";
  private boolean contentFetch;
  
  CVSWorkspaceSubscriber(QualifiedName id, String name)
  {
    super(id, name);
    
    ResourceVariantByteStore baseSynchronizer = new CVSBaseResourceVariantTree();
    baseTree = new CVSResourceVariantTree(baseSynchronizer, null, getCacheFileContentsHint())
    {
      public IResource[] refresh(IResource[] resources, int depth, IProgressMonitor monitor)
        throws TeamException
      {
        try
        {
          monitor.beginTask(null, 100);
          return new IResource[0];
        }
        finally
        {
          monitor.done();
        }
      }
    };
    CVSDescendantResourceVariantByteStore remoteSynchronizer = new CVSDescendantResourceVariantByteStore(
      baseSynchronizer, 
      new PersistantResourceVariantByteStore(new QualifiedName("org.eclipse.team.cvs", "remote-resource-key")));
    remoteTree = new CVSResourceVariantTree(remoteSynchronizer, null, getCacheFileContentsHint())
    {
      public boolean isCacheFileContentsHint()
      {
        return getCacheFileContentsHint();
      }
    };
    ResourceStateChangeListeners.getListener().addResourceStateChangeListener(this);
  }
  
  public IResource[] roots()
  {
    List result = new ArrayList();
    IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
    for (int i = 0; i < projects.length; i++)
    {
      IProject project = projects[i];
      if (project.isOpen())
      {
        RepositoryProvider provider = RepositoryProvider.getProvider(project, CVSProviderPlugin.getTypeId());
        if (provider != null) {
          result.add(project);
        }
      }
    }
    return (IProject[])result.toArray(new IProject[result.size()]);
  }
  
  public void resourceSyncInfoChanged(IResource[] changedResources)
  {
    internalResourceSyncInfoChanged(changedResources, true);
  }
  
  private void internalResourceSyncInfoChanged(IResource[] changedResources, boolean canModifyWorkspace)
  {
    getRemoteByteStore().handleResourceChanges(changedResources, canModifyWorkspace);
    fireTeamResourceChange(SubscriberChangeEvent.asSyncChangedDeltas(this, changedResources));
  }
  
  public void externalSyncInfoChange(IResource[] changedResources)
  {
    internalResourceSyncInfoChanged(changedResources, false);
  }
  
  public void resourceModified(IResource[] changedResources) {}
  
  public void projectConfigured(IProject project)
  {
    SubscriberChangeEvent delta = new SubscriberChangeEvent(this, 2, project);
    fireTeamResourceChange(new SubscriberChangeEvent[] { delta });
  }
  
  public void projectDeconfigured(IProject project)
  {
    try
    {
      getRemoteTree().flushVariants(project, 2);
    }
    catch (TeamException e)
    {
      CVSProviderPlugin.log(e);
    }
    SubscriberChangeEvent delta = new SubscriberChangeEvent(this, 4, project);
    fireTeamResourceChange(new SubscriberChangeEvent[] { delta });
  }
  
  public void setRemote(IResource resource, IResourceVariant remote, IProgressMonitor monitor)
    throws TeamException
  {
    IResource[] changedResources = 
      ((CVSResourceVariantTree)getRemoteTree()).collectChanges(resource, remote, 2, monitor);
    if (changedResources.length != 0) {
      fireTeamResourceChange(SubscriberChangeEvent.asSyncChangedDeltas(this, changedResources));
    }
  }
  
  protected IResourceVariantTree getBaseTree()
  {
    return baseTree;
  }
  
  protected IResourceVariantTree getRemoteTree()
  {
    return remoteTree;
  }
  
  public void collectOutOfSync(IResource[] resources, int depth, SyncInfoSet set, IProgressMonitor monitor)
  {
    monitor.beginTask(null, -1);
    for (int i = 0; i < resources.length; i++)
    {
      IResource resource = resources[i];
      try
      {
        if (!isSupervised(resource)) {
          return;
        }
      }
      catch (TeamException e)
      {
        CVSProviderPlugin.log(e);
        try
        {
          visit(resource, new IResourceVisitor()
          {
            private final IProgressMonitor val$monitor;
            private final SyncInfoSet val$set;
            
            public boolean visit(IResource innerResource)
              throws CoreException
            {
              try
              {
                Policy.checkCanceled(val$monitor);
                if (innerResource.getType() != 1) {
                  val$monitor.subTask(NLS.bind(CVSMessages.CVSWorkspaceSubscriber_1, new String[] { innerResource.getFullPath().toString() }));
                }
                if (isOutOfSync(innerResource, val$monitor))
                {
                  SyncInfo info = getSyncInfo(innerResource);
                  if ((info != null) && (info.getKind() != 0)) {
                    val$set.add(info);
                  }
                }
              }
              catch (TeamException e)
              {
                val$set.addError(new TeamStatus(
                  4, "org.eclipse.team.cvs.core", 1, 
                  NLS.bind(CVSMessages.CVSWorkspaceSubscriber_2, new String[] { innerResource.getFullPath().toString(), e.getMessage() }), e, innerResource));
              }
              return true;
            }
          }, depth);
        }
        catch (CoreException e)
        {
          set.addError(new TeamStatus(
            4, "org.eclipse.team.cvs.core", 2, 
            e.getMessage(), e, ResourcesPlugin.getWorkspace().getRoot()));
        }
      }
    }
    monitor.done();
  }
  
  private void visit(IResource resource, IResourceVisitor visitor, int depth)
    throws CoreException
  {
    boolean keepGoing = visitor.visit(resource);
    if ((keepGoing) && (depth != 0))
    {
      IResource[] members = members(resource);
      for (int i = 0; i < members.length; i++)
      {
        IResource member = members[i];
        visit(member, visitor, depth == 1 ? 0 : 2);
      }
    }
  }
  
  boolean isOutOfSync(IResource resource, IProgressMonitor monitor)
    throws TeamException
  {
    return (hasIncomingChange(resource)) || (hasOutgoingChange(resource, monitor));
  }
  
  private boolean hasIncomingChange(IResource resource)
    throws TeamException
  {
    return getRemoteByteStore().isVariantKnown(resource);
  }
  
  private boolean hasOutgoingChange(IResource resource, IProgressMonitor monitor)
    throws CVSException
  {
    if ((resource.getType() == 4) || (resource.getType() == 8)) {
      return false;
    }
    int state = EclipseSynchronizer.getInstance().getModificationState(resource.getParent());
    if (state == 1) {
      return false;
    }
    if (resource.getType() == 1)
    {
      ICVSFile file = CVSWorkspaceRoot.getCVSFileFor((IFile)resource);
      return file.isModified(monitor);
    }
    ICVSFolder folder = CVSWorkspaceRoot.getCVSFolderFor((IContainer)resource);
    return (!folder.isCVSFolder()) && (!folder.isIgnored());
  }
  
  private CVSDescendantResourceVariantByteStore getRemoteByteStore()
  {
    return (CVSDescendantResourceVariantByteStore)((CVSResourceVariantTree)getRemoteTree()).getByteStore();
  }
  
  /* Error */
  public void updateRemote(CVSTeamProvider provider, ICVSFolder folder, boolean recurse, IProgressMonitor monitor)
    throws TeamException
  {
    // Byte code:
    //   0: aload 4
    //   2: aconst_null
    //   3: iconst_m1
    //   4: invokeinterface 503 3 0
    //   9: aload_2
    //   10: invokeinterface 511 1 0
    //   15: astore 5
    //   17: aload 5
    //   19: ifnull +52 -> 71
    //   22: aload_0
    //   23: aload 5
    //   25: iconst_0
    //   26: aload 4
    //   28: bipush 50
    //   30: invokestatic 476	org/eclipse/team/internal/ccvs/core/Policy:subMonitorFor	(Lorg/eclipse/core/runtime/IProgressMonitor;I)Lorg/eclipse/core/runtime/IProgressMonitor;
    //   33: invokevirtual 471	org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber:buildBaseTree	(Lorg/eclipse/core/resources/IResource;ZLorg/eclipse/core/runtime/IProgressMonitor;)Lorg/eclipse/team/internal/ccvs/core/ICVSRemoteResource;
    //   36: astore 6
    //   38: aload_0
    //   39: aload 5
    //   41: aload 6
    //   43: checkcast 224	org/eclipse/team/core/variants/IResourceVariant
    //   46: aload 4
    //   48: bipush 50
    //   50: invokestatic 476	org/eclipse/team/internal/ccvs/core/Policy:subMonitorFor	(Lorg/eclipse/core/runtime/IProgressMonitor;I)Lorg/eclipse/core/runtime/IProgressMonitor;
    //   53: invokevirtual 470	org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber:setRemote	(Lorg/eclipse/core/resources/IResource;Lorg/eclipse/team/core/variants/IResourceVariant;Lorg/eclipse/core/runtime/IProgressMonitor;)V
    //   56: goto +15 -> 71
    //   59: astore 7
    //   61: aload 4
    //   63: invokeinterface 502 1 0
    //   68: aload 7
    //   70: athrow
    //   71: aload 4
    //   73: invokeinterface 502 1 0
    //   78: return
    // Line number table:
    //   Java source line #272	-> byte code offset #0
    //   Java source line #273	-> byte code offset #9
    //   Java source line #274	-> byte code offset #17
    //   Java source line #275	-> byte code offset #22
    //   Java source line #276	-> byte code offset #23
    //   Java source line #277	-> byte code offset #25
    //   Java source line #278	-> byte code offset #26
    //   Java source line #275	-> byte code offset #33
    //   Java source line #279	-> byte code offset #38
    //   Java source line #281	-> byte code offset #59
    //   Java source line #282	-> byte code offset #61
    //   Java source line #283	-> byte code offset #68
    //   Java source line #282	-> byte code offset #71
    //   Java source line #284	-> byte code offset #78
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	79	0	this	CVSWorkspaceSubscriber
    //   0	79	1	provider	CVSTeamProvider
    //   0	79	2	folder	ICVSFolder
    //   0	79	3	recurse	boolean
    //   0	79	4	monitor	IProgressMonitor
    //   15	25	5	resource	IResource
    //   36	6	6	tree	ICVSResource
    //   59	10	7	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   0	59	59	finally
  }
  
  public ICVSRemoteResource buildBaseTree(IResource resource, boolean immutable, IProgressMonitor monitor)
    throws TeamException
  {
    try
    {
      monitor.beginTask(null, -1);
      return ((CVSResourceVariantTree)getBaseTree()).buildTree(null, resource, immutable, monitor);
    }
    finally
    {
      monitor.done();
    }
  }
  
  public ICVSRemoteResource buildRemoteTree(IResource resource, boolean immutable, IProgressMonitor monitor)
    throws TeamException
  {
    try
    {
      monitor.beginTask(null, -1);
      return ((CVSResourceVariantTree)getRemoteTree()).buildTree(null, resource, immutable, monitor);
    }
    finally
    {
      monitor.done();
    }
  }
  
  public int getState(ResourceMapping mapping, int stateMask, IProgressMonitor monitor)
    throws CoreException
  {
    if ((stateMask & 0x200) == 0)
    {
      ResourceTraversal[] traversals = mapping.getTraversals(new SubscriberResourceMappingContext(this, false), monitor);
      if (hasLocalChanges(traversals, monitor))
      {
        int state = 256;
        state |= getOutgoingKind(traversals, monitor);
        return state;
      }
      return 0;
    }
    return super.getState(mapping, stateMask, monitor);
  }
  
  private int getOutgoingKind(ResourceTraversal[] traversals, IProgressMonitor monitor)
    throws CoreException
  {
    int kind = 0;
    for (int i = 0; i < traversals.length; i++)
    {
      ResourceTraversal traversal = traversals[i];
      IResource[] resources = traversal.getResources();
      for (int j = 0; j < resources.length; j++)
      {
        IResource resource = resources[j];
        IDiff node = getDiff(resource);
        if (node == null) {
          return 4;
        }
        int nextKind = node.getKind();
        if (kind == 0) {
          kind = nextKind;
        }
        if ((nextKind != kind) || (nextKind == 4)) {
          return 4;
        }
      }
    }
    return kind;
  }
  
  public boolean hasLocalChanges(ResourceTraversal[] traversals, IProgressMonitor monitor)
    throws CoreException
  {
    monitor = Policy.monitorFor(monitor);
    for (int i = 0; i < traversals.length; i++)
    {
      ResourceTraversal traversal = traversals[i];
      IResource[] resources = traversal.getResources();
      switch (traversal.getDepth())
      {
      case 0: 
        for (int j = 0; j < resources.length; j++)
        {
          IResource resource = resources[j];
          if (isDirectlyDirty(resource, monitor)) {
            return true;
          }
        }
        break;
      case 2: 
        for (int j = 0; j < resources.length; j++)
        {
          IResource resource = resources[j];
          if (isDirty(resource, monitor)) {
            return true;
          }
        }
        break;
      case 1: 
        for (int j = 0; j < resources.length; j++)
        {
          IResource resource = resources[j];
          if (isDirectlyDirty(resource, monitor)) {
            return true;
          }
          IResource[] children = members(resource);
          for (int k = 0; k < children.length; k++)
          {
            IResource child = children[k];
            if (isDirectlyDirty(child, monitor)) {
              return true;
            }
          }
        }
      }
    }
    return false;
  }
  
  private boolean isDirectlyDirty(IResource resource, IProgressMonitor monitor)
    throws CoreException
  {
    if (resource.getType() == 1)
    {
      if (isDirty(resource, monitor)) {
        return true;
      }
    }
    else
    {
      IDiff node = getDiff(resource);
      if ((node != null) && 
        ((node instanceof IThreeWayDiff)) && 
        (((IThreeWayDiff)node).getLocalChange() != null) && 
        (((IThreeWayDiff)node).getLocalChange().getKind() != 0)) {
        return true;
      }
    }
    return false;
  }
  
  public boolean isDirty(ICVSResource cvsResource, IProgressMonitor monitor)
    throws CVSException
  {
    if (cvsResource.exists()) {
      return (!cvsResource.isIgnored()) && (cvsResource.isModified(monitor));
    }
    return (cvsResource.isManaged()) && (cvsResource.isModified(monitor));
  }
  
  public boolean isDirty(IResource resource, IProgressMonitor monitor)
    throws CVSException
  {
    try
    {
      ICVSResource cvsResource = CVSWorkspaceRoot.getCVSResourceFor(resource);
      return isDirty(cvsResource, monitor);
    }
    catch (CVSException e)
    {
      boolean accessible = resource.getProject().isAccessible();
      if (accessible) {
        throw e;
      }
      return accessible;
    }
  }
  
  public Object getAdapter(Class adapter)
  {
    if (adapter == ActiveChangeSetManager.class) {
      return CVSProviderPlugin.getPlugin().getChangeSetManager();
    }
    return super.getAdapter(adapter);
  }
  
  /* Error */
  public void refreshWithContentFetch(ResourceTraversal[] traversals, IProgressMonitor monitor)
    throws TeamException
  {
    // Byte code:
    //   0: aload_0
    //   1: iconst_1
    //   2: putfield 424	org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber:contentFetch	Z
    //   5: aload_0
    //   6: aload_1
    //   7: aload_2
    //   8: invokevirtual 466	org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber:refresh	([Lorg/eclipse/core/resources/mapping/ResourceTraversal;Lorg/eclipse/core/runtime/IProgressMonitor;)V
    //   11: goto +11 -> 22
    //   14: astore_3
    //   15: aload_0
    //   16: iconst_0
    //   17: putfield 424	org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber:contentFetch	Z
    //   20: aload_3
    //   21: athrow
    //   22: aload_0
    //   23: iconst_0
    //   24: putfield 424	org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber:contentFetch	Z
    //   27: return
    // Line number table:
    //   Java source line #433	-> byte code offset #0
    //   Java source line #434	-> byte code offset #5
    //   Java source line #435	-> byte code offset #14
    //   Java source line #436	-> byte code offset #15
    //   Java source line #437	-> byte code offset #20
    //   Java source line #436	-> byte code offset #22
    //   Java source line #438	-> byte code offset #27
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	28	0	this	CVSWorkspaceSubscriber
    //   0	28	1	traversals	ResourceTraversal[]
    //   0	28	2	monitor	IProgressMonitor
    //   14	7	3	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   0	14	14	finally
  }
  
  protected boolean getCacheFileContentsHint()
  {
    return contentFetch;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.CVSWorkspaceSubscriber
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import java.util.HashSet;
import java.util.Set;
import org.eclipse.team.core.RepositoryProviderType;
import org.eclipse.team.core.importing.provisional.BundleImporterDelegate;

public class CvsBundleImporterDelegate
  extends BundleImporterDelegate
{
  private static Set SUPPORTED_VALUES = new HashSet();
  private static final String SCM = "scm:";
  private static final String CVS = "cvs";
  private static final String COLON = ":";
  private static final String PIPE = "|";
  private RepositoryProviderType providerType;
  
  static
  {
    SUPPORTED_VALUES.add("scm:cvs:");
    SUPPORTED_VALUES.add("scm:cvs|");
  }
  
  protected Set getSupportedValues()
  {
    return SUPPORTED_VALUES;
  }
  
  protected RepositoryProviderType getProviderType()
  {
    if (providerType == null) {
      providerType = RepositoryProviderType.getProviderType(CVSProviderPlugin.getTypeId());
    }
    return providerType;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.CvsBundleImporterDelegate
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

public class EditorsInfo
{
  private String userName;
  private String fileName;
  private String dateString;
  private String computerName;
  
  public String getUserName()
  {
    return userName;
  }
  
  public void setUserName(String userName)
  {
    this.userName = userName;
  }
  
  public String getDateString()
  {
    return dateString;
  }
  
  public String getFileName()
  {
    return fileName;
  }
  
  public void setDateString(String dateString)
  {
    this.dateString = dateString;
  }
  
  public void setFileName(String fileName)
  {
    this.fileName = fileName;
  }
  
  public String getComputerName()
  {
    return computerName;
  }
  
  public void setComputerName(String computerName)
  {
    this.computerName = computerName;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.EditorsInfo
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

public abstract interface ICVSDecoratorEnablementListener
{
  public abstract void decoratorEnablementChanged(boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSDecoratorEnablementListener
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import java.util.Date;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.internal.ccvs.core.syncinfo.NotifyInfo;
import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;

public abstract interface ICVSFile
  extends ICVSResource, ICVSStorage
{
  public static final int UPDATED = 1;
  public static final int MERGED = 2;
  public static final int UPDATE_EXISTING = 3;
  public static final int CREATED = 4;
  public static final int NO_NOTIFICATION = 0;
  public static final int NOTIFY_ON_EDIT = 1;
  public static final int NOTIFY_ON_UNEDIT = 2;
  public static final int NOTIFY_ON_COMMIT = 4;
  public static final int NOTIFY_ON_ALL = 7;
  public static final int UNKNOWN = 0;
  public static final int CLEAN = 1;
  public static final int DIRTY = 2;
  
  public abstract byte[] getSyncBytes()
    throws CVSException;
  
  public abstract void setSyncInfo(ResourceSyncInfo paramResourceSyncInfo, int paramInt)
    throws CVSException;
  
  public abstract void setSyncBytes(byte[] paramArrayOfByte, int paramInt)
    throws CVSException;
  
  public abstract void setReadOnly(boolean paramBoolean)
    throws CVSException;
  
  public abstract boolean isReadOnly()
    throws CVSException;
  
  public abstract void setExecutable(boolean paramBoolean)
    throws CVSException;
  
  public abstract boolean isExecutable()
    throws CVSException;
  
  public abstract void copyTo(String paramString)
    throws CVSException;
  
  public abstract Date getTimeStamp();
  
  public abstract void setTimeStamp(Date paramDate)
    throws CVSException;
  
  public abstract boolean isModified(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract ILogEntry[] getLogEntries(IProgressMonitor paramIProgressMonitor)
    throws TeamException;
  
  public abstract void edit(int paramInt, boolean paramBoolean, IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract void unedit(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract void checkedIn(String paramString, boolean paramBoolean)
    throws CVSException;
  
  public abstract NotifyInfo getPendingNotification()
    throws CVSException;
  
  public abstract void notificationCompleted()
    throws CVSException;
  
  public abstract boolean isEdited()
    throws CVSException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSFile
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;

public abstract interface ICVSFileModificationValidator
{
  public abstract IStatus validateMoveDelete(IFile[] paramArrayOfIFile, IProgressMonitor paramIProgressMonitor);
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSFileModificationValidator
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.internal.ccvs.core.syncinfo.FolderSyncInfo;

public abstract interface ICVSFolder
  extends ICVSResource
{
  public static final int FILE_MEMBERS = 1;
  public static final int FOLDER_MEMBERS = 2;
  public static final int IGNORED_MEMBERS = 4;
  public static final int UNMANAGED_MEMBERS = 8;
  public static final int MANAGED_MEMBERS = 16;
  public static final int EXISTING_MEMBERS = 32;
  public static final int PHANTOM_MEMBERS = 64;
  public static final int ALL_MEMBERS = 127;
  public static final int ALL_EXISTING_MEMBERS = 63;
  public static final int ALL_UNIGNORED_MEMBERS = 123;
  
  public abstract ICVSResource[] fetchChildren(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract ICVSResource[] members(int paramInt)
    throws CVSException;
  
  public abstract ICVSFolder getFolder(String paramString)
    throws CVSException;
  
  public abstract ICVSFile getFile(String paramString)
    throws CVSException;
  
  public abstract ICVSResource getChild(String paramString)
    throws CVSException;
  
  public abstract void mkdir()
    throws CVSException;
  
  public abstract FolderSyncInfo getFolderSyncInfo()
    throws CVSException;
  
  public abstract void setFolderSyncInfo(FolderSyncInfo paramFolderSyncInfo)
    throws CVSException;
  
  public abstract void acceptChildren(ICVSResourceVisitor paramICVSResourceVisitor)
    throws CVSException;
  
  public abstract boolean isCVSFolder()
    throws CVSException;
  
  public abstract void run(ICVSRunnable paramICVSRunnable, IProgressMonitor paramIProgressMonitor)
    throws CVSException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSFolder
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

public abstract interface ICVSListener
{
  public abstract void repositoryAdded(ICVSRepositoryLocation paramICVSRepositoryLocation);
  
  public abstract void repositoryRemoved(ICVSRepositoryLocation paramICVSRepositoryLocation);
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSListener
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import java.io.InputStream;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.core.TeamException;

public abstract interface ICVSRemoteFile
  extends ICVSRemoteResource, ICVSFile
{
  public abstract InputStream getContents(IProgressMonitor paramIProgressMonitor)
    throws TeamException;
  
  public abstract ILogEntry getLogEntry(IProgressMonitor paramIProgressMonitor)
    throws TeamException;
  
  public abstract ILogEntry[] getLogEntries(IProgressMonitor paramIProgressMonitor)
    throws TeamException;
  
  public abstract String getRevision()
    throws TeamException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSRemoteFile
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.team.internal.ccvs.core.client.Command.LocalOption;

public abstract interface ICVSRemoteFolder
  extends ICVSRemoteResource, ICVSFolder
{
  public static final String REPOSITORY_ROOT_FOLDER_NAME = "";
  
  public abstract CVSTag getTag();
  
  public abstract Command.LocalOption[] getLocalOptions();
  
  public abstract boolean isExpandable();
  
  public abstract boolean isDefinedModule();
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSRemoteFolder
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.internal.ccvs.core.client.Command.LocalOption;

public abstract interface ICVSRemoteResource
  extends ICVSResource, IAdaptable
{
  public abstract boolean isContainer();
  
  public abstract ICVSRepositoryLocation getRepository();
  
  public abstract ICVSRemoteResource getRemoteParent();
  
  public abstract boolean exists(IProgressMonitor paramIProgressMonitor)
    throws TeamException;
  
  public abstract String getRepositoryRelativePath();
  
  public abstract boolean equals(Object paramObject);
  
  public abstract ICVSRemoteResource forTag(CVSTag paramCVSTag);
  
  public abstract IStatus tag(CVSTag paramCVSTag, Command.LocalOption[] paramArrayOfLocalOption, IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract ICVSRemoteResource[] members(IProgressMonitor paramIProgressMonitor)
    throws TeamException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSRemoteResource
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;

public abstract interface ICVSRepositoryLocation
  extends IAdaptable
{
  public static final int USE_DEFAULT_PORT = 0;
  
  public abstract IConnectionMethod getMethod();
  
  public abstract String getHost();
  
  public abstract int getPort();
  
  public abstract String getRootDirectory();
  
  public abstract String getLocation(boolean paramBoolean);
  
  public abstract ICVSRemoteResource[] members(CVSTag paramCVSTag, boolean paramBoolean, IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract ICVSRemoteFile getRemoteFile(String paramString, CVSTag paramCVSTag);
  
  public abstract ICVSRemoteFolder getRemoteFolder(String paramString, CVSTag paramCVSTag);
  
  public abstract String getEncoding();
  
  public abstract int getTimeout();
  
  public abstract String getUsername();
  
  public abstract IUserInfo getUserInfo(boolean paramBoolean);
  
  public abstract void flushUserInfo();
  
  public abstract void validateConnection(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract void setAllowCaching(boolean paramBoolean);
  
  public abstract boolean getUserInfoCached();
  
  public abstract void setUsername(String paramString);
  
  public abstract void setPassword(String paramString);
  
  public abstract IUserAuthenticator getUserAuthenticator();
  
  public abstract void setUserAuthenticator(IUserAuthenticator paramIUserAuthenticator);
  
  public abstract void setEncoding(String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;

public abstract interface ICVSResource
{
  public abstract String getName();
  
  public abstract boolean isManaged()
    throws CVSException;
  
  public abstract void unmanage(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
  
  public abstract boolean isIgnored()
    throws CVSException;
  
  public abstract void setIgnoredAs(String paramString)
    throws CVSException;
  
  public abstract boolean isFolder();
  
  public abstract boolean exists()
    throws CVSException;
  
  public abstract IResource getIResource();
  
  public abstract String getRelativePath(ICVSFolder paramICVSFolder)
    throws CVSException;
  
  public abstract String getRepositoryRelativePath()
    throws CVSException;
  
  public abstract String getRemoteLocation(ICVSFolder paramICVSFolder)
    throws CVSException;
  
  public abstract ResourceSyncInfo getSyncInfo()
    throws CVSException;
  
  public abstract void delete()
    throws CVSException;
  
  public abstract ICVSFolder getParent();
  
  public abstract void accept(ICVSResourceVisitor paramICVSResourceVisitor)
    throws CVSException;
  
  public abstract void accept(ICVSResourceVisitor paramICVSResourceVisitor, boolean paramBoolean)
    throws CVSException;
  
  public abstract boolean isModified(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSResource
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

public abstract interface ICVSResourceVisitor
{
  public abstract void visitFile(ICVSFile paramICVSFile)
    throws CVSException;
  
  public abstract void visitFolder(ICVSFolder paramICVSFolder)
    throws CVSException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSResourceVisitor
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import org.eclipse.core.runtime.IProgressMonitor;

public abstract interface ICVSRunnable
{
  public abstract void run(IProgressMonitor paramIProgressMonitor)
    throws CVSException;
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ccvs.core.ICVSRunnable
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ccvs.core;

import java.io.InputStream;
import org.eclipse.core.runtime.IProgressMonitor;

public abstract interface ICVSStorage
{
  pu
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd