import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
private ISVNEventHandler buildSvnEventHandler ( String desc, BufferedWriter outputWriter ) {
	lineCount = 0;
	return new ISVNEventHandler() {

		@Override
		public void checkCancelled ()
				throws SVNCancelException {

		}

		@Override
		public void handleEvent ( SVNEvent event, double progress )
				throws SVNException {
			// logger.debug("progess: " + progress + " " + event);
			if ( event.getURL() == null && event.getFile() != null ) {
				updateProgress( outputWriter, desc + event.getFile().getName() );
			} else if ( event.getURL() != null ) {
				updateProgress( outputWriter, desc + event.getURL() );
			} else {
				updateProgress( outputWriter, desc + event );
			}
		}
	};
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public SVNStatusClient createStatusClient() {
  final SVNStatusClient result = myVcs.createStatusClient();
  result.setFilesProvider(myFileProvider);
  result.setEventHandler(new ISVNEventHandler() {
    public void handleEvent(SVNEvent event, double progress) throws SVNException {
      //
    }

    public void checkCancelled() throws SVNCancelException {
      if (myIndicator != null) {
        myIndicator.checkCanceled();
      }
    }
  });
  return result;
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
  if (myCheckCancel && myProgress != null) {
    try {
      myProgress.checkCanceled();
    }
    catch (ProcessCanceledException ex) {
      throw new SVNCancelException();
    }
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
  if (myProgressIndicator != null) {
    myProgressIndicator.checkCanceled();
    if (myProgressIndicator.isCanceled()) {
      SVNErrorManager.cancel(SvnBundle.message("exception.text.update.operation.cancelled"), SVNLogType.DEFAULT);
    }
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
private SVNAuthentication getWithPassiveImpl(SvnAuthenticationManager passive) throws SVNException {
  try {
    return passive.getFirstAuthentication(myKind, myRealm, myUrl);
  }
  catch (SVNCancelException e) {
    return null;
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public boolean checkCancelled() {
  if (!myWasCancelled && myCommand.getCanceller() != null) {
    try {
      myCommand.getCanceller().checkCancelled();
    }
    catch (SVNCancelException e) {
      // indicates command should be cancelled
      myWasCancelled = true;
    }
  }

  return myWasCancelled;
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
private static ProgressTracker createUpgradeHandler(@NotNull final ProgressIndicator indicator,
                                                     @NotNull final String cleanupMessage,
                                                     @NotNull final String upgradeMessage) {
  return new ProgressTracker() {
    @Override
    public void consume(ProgressEvent event) throws SVNException {
      if (event.getFile() != null) {
        if (EventAction.UPGRADED_PATH.equals(event.getAction())) {
          indicator.setText2("Upgraded path " + VcsUtil.getPathForProgressPresentation(event.getFile()));
        }
        // fake event indicating cleanup start
        if (EventAction.UPDATE_STARTED.equals(event.getAction())) {
          indicator.setText(cleanupMessage);
        }
        // fake event indicating upgrade start
        if (EventAction.UPDATE_COMPLETED.equals(event.getAction())) {
          indicator.setText(upgradeMessage);
        }
      }
    }

    @Override
    public void checkCancelled() throws SVNCancelException {
      indicator.checkCanceled();
    }
  };
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
@NotNull
public ProgressTracker createEventHandler() {
  return new ProgressTracker() {
    @Override
    public void consume(ProgressEvent event) throws SVNException {
    }

    @Override
    public void checkCancelled() throws SVNCancelException {
      SvnRecursiveStatusWalker.this.checkCanceled();
    }
  };
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
@Override
public void checkCancelled() throws SVNCancelException {
  final ProgressManager pm = ProgressManager.getInstance();
  final ProgressIndicator pi = pm.getProgressIndicator();
  if (pi != null) {
    if (pi.isCanceled()) throw new SVNCancelException();
  }
  ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  if (indicator != null && indicator.isCanceled()) {
    throw new SVNCancelException();
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
  try {
    getRef().checkCancelled();
  } catch (ProcessCanceledException e) {
    throw new SVNCancelException();
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
  if (cancelFlag) {
    cancelFlag = false;
    invokeLater(1); // reset progressBar
    throw new SVNCancelException();
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
private void doInBackground(Project project, VirtualFile vf, String url, boolean checkout, String target) {
  final SvnVcs vcs = SvnVcs.getInstance(project);
  try {
    final File ioFile = new File(vf.getPath());
    if (addToExternalProperty(vcs, ioFile, target, url)) return;
    final VcsDirtyScopeManager dirtyScopeManager = VcsDirtyScopeManager.getInstance(project);
    final FilePathImpl filePath = new FilePathImpl(ioFile, true);
    dirtyScopeManager.fileDirty(filePath);
    if (checkout) {
      // +-
      final SVNUpdateClient client = vcs.createUpdateClient();
      client.setEventHandler(new ISVNEventHandler() {
        @Override
        public void handleEvent(SVNEvent event, double progress) throws SVNException {
        }

        @Override
        public void checkCancelled() throws SVNCancelException {
          final ProgressIndicator pi = ProgressManager.getInstance().getProgressIndicator();
          if (pi != null && pi.isCanceled()) throw new SVNCancelException();
        }
      });
      client.doUpdate(ioFile, SVNRevision.HEAD, SVNDepth.UNKNOWN, false, false);
      vf.refresh(true, true, new Runnable() {
        @Override
        public void run() {
          dirtyScopeManager.dirDirtyRecursively(filePath);
        }
      });
    }
  }
  catch (SVNException e1) {
    AbstractVcsHelper.getInstance(project).showError(new VcsException(e1), "Create External");
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
  final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  if (indicator != null && indicator.isCanceled()) {
    throw new SVNCancelException();
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
  if (myIndicator != null && myIndicator.isCanceled()) {
    throw new SVNCancelException(SVNErrorMessage.create(SVNErrorCode.CANCELLED, "Operation cancelled"));
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public MyLogEntryHandler(SvnVcs vcs, final String url,
                             final SVNRevision pegRevision,
                             String lastPath,
                             final ThrowableConsumer<VcsFileRevision, SVNException> result,
                             SVNURL repoRootURL, Charset charset)
      throws SVNException, VcsException {
      myVcs = vcs;
      myLastPathCorrector = new SvnPathThroughHistoryCorrection(lastPath);
      myLastPath = lastPath;
      myCharset = charset;
      myIndicator = ProgressManager.getInstance().getProgressIndicator();
      myResult = result;
      myPegRevision = pegRevision;
      myUrl = url;
      myRepositoryRoot = repoRootURL;
      myTracker = new SvnMergeSourceTracker(new ThrowableConsumer<Pair<LogEntry, Integer>, SVNException>() {
        @Override
        public void consume(final Pair<LogEntry, Integer> svnLogEntryIntegerPair) throws SVNException {
          final LogEntry logEntry = svnLogEntryIntegerPair.getFirst();

          if (myIndicator != null) {
            if (myIndicator.isCanceled()) {
              SVNErrorManager.cancel(SvnBundle.message("exception.text.update.operation.cancelled"), SVNLogType.DEFAULT);
            }
            myIndicator.setText2(SvnBundle.message("progress.text2.revision.processed", logEntry.getRevision()));
          }
          LogEntryPath entryPath = null;
          String copyPath = null;
          final int mergeLevel = svnLogEntryIntegerPair.getSecond();

          if (! myLastPathCorrector.isRoot()) {
            myLastPathCorrector.consume(logEntry);
            entryPath = myLastPathCorrector.getDirectlyMentioned();
            copyPath = null;
            if (entryPath != null) {
              copyPath = entryPath.getCopyPath();
            } else {
              // if there are no path with exact match, check whether parent or child paths had changed
              // "entry path" is allowed to be null now; if it is null, last path would be taken for revision construction

              // Separate LogEntry is issued for each "merge source" revision. These "merge source" revisions are treated as child
              // revisions of some other revision - this way we construct merge hierarchy.
              // mergeLevel >= 0 indicates that we are currently processing some "merge source" revision. This "merge source" revision
              // contains changes from some other branch - so checkForChildChanges() and checkForParentChanges() return "false".
              // Because of this case we apply these methods only for non-"merge source" revisions - this means mergeLevel < 0.
              // TODO: Do not apply path filtering even for log entries on the first level => just output of 'svn log' should be returned.
              // TODO: Looks like there is no cases when we issue 'svn log' for some parent paths or some other cases where we need such
              // TODO: filtering. Check user feedback on this.
//              if (mergeLevel < 0 && !checkForChildChanges(logEntry) && !checkForParentChanges(logEntry)) return;
            }
          }

          final SvnFileRevision revision = createRevision(logEntry, copyPath, entryPath);
          if (mergeLevel >= 0) {
            addToListByLevel((SvnFileRevision)myPrevious, revision, mergeLevel);
          }
          else {
            myResult.consume(revision);
            myPrevious = revision;
          }
          if (myThrowCancelOnMeetPathCreation && myUrl.equals(revision.getURL()) && entryPath != null && entryPath.getType() == 'A') {
            throw new SVNCancelException();
          }
        }

      });
    }
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
@Test
public void testRefusedAdd ()throws Exception {
  SVNWCDb db = new SVNWCDb();
  final File ioFile = new File(myWorkingCopyRoot, filename);
  ioFile.getParentFile().mkdirs();
  ioFile.createNewFile();
  try {
    db.open(ISVNWCDb.SVNWCDbOpenMode.ReadWrite, new DefaultSVNOptions(), true, true);
    SVNWCContext context = new SVNWCContext(db, new ISVNEventHandler() {
      @Override
      public void handleEvent(SVNEvent event, double progress) throws SVNException {
      }

      @Override
      public void checkCancelled() throws SVNCancelException {
      }
    });

    File file = context.acquireWriteLock(myWorkingCopyRoot, false, true);
    boolean failed = false;
    try {
      SVNWCClient client = new SVNWCClient((ISVNRepositoryPool)null, new DefaultSVNOptions());
      client.doAdd(ioFile, true, false, false, true);
    }
    catch (SVNException e) {
      Assert.assertEquals(155004, e.getErrorMessage().getErrorCode().getCode());
      failed = true;
    }
    finally {
      context.releaseWriteLock(myWorkingCopyRoot);
    }
    Assert.assertTrue(failed);

    SVNStatusClient readClient = new SVNStatusClient((ISVNRepositoryPool)null, new DefaultSVNOptions());
    //readClient.doStatus(ioFile, false);
    readClient.doStatus(myWorkingCopyRoot, false);
  }
  finally {
    ioFile.delete();
    db.close();
  }
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
/**
 * WCClient
 */
@Override
public void checkCancelled() throws SVNCancelException {
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled() throws SVNCancelException {
}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
@Override
public void checkCancelled() throws SVNCancelException {
	// TODO Auto-generated method stub

}
 

import org.tmatesoft.svn.core.SVNCancelException; //导入依赖的package包/类
public void checkCancelled()
    throws SVNCancelException
{
    // null
}