Java SVNStatusType类代码示例

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private static boolean checkStatus(SVNClientManager clientManager, InputFile inputFile) throws SVNException {
  SVNStatusClient statusClient = clientManager.getStatusClient();
  try {
    SVNStatus status = statusClient.doStatus(inputFile.file(), false);
    if (status == null) {
      LOG.debug("File {} returns no svn state. Skipping it.", inputFile);
      return false;
    }
    if (status.getContentsStatus() != SVNStatusType.STATUS_NORMAL) {
      LOG.debug("File {} is not versionned or contains local modifications. Skipping it.", inputFile);
      return false;
    }
  } catch (SVNException e) {
    if (SVNErrorCode.WC_PATH_NOT_FOUND.equals(e.getErrorMessage().getErrorCode())
      || SVNErrorCode.WC_NOT_WORKING_COPY.equals(e.getErrorMessage().getErrorCode())) {
      LOG.debug("File {} is not versionned. Skipping it.", inputFile);
      return false;
    }
    throw e;
  }
  return true;
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private SVNStatusType getStatusType(char first) {
  final SVNStatusType contentsStatus;
  if ('A' == first) {
    contentsStatus = SVNStatusType.STATUS_ADDED;
  } else if ('D' == first) {
    contentsStatus = SVNStatusType.STATUS_DELETED;
  } else if ('U' == first) {
    contentsStatus = SVNStatusType.CHANGED;
  } else if ('C' == first) {
    contentsStatus = SVNStatusType.CONFLICTED;
  } else if ('G' == first) {
    contentsStatus = SVNStatusType.MERGED;
  } else if ('R' == first) {
    contentsStatus = SVNStatusType.STATUS_REPLACED;
  } else if ('E' == first) {
    contentsStatus = SVNStatusType.STATUS_OBSTRUCTED;
  } else {
    contentsStatus = SVNStatusType.STATUS_NORMAL;
  }
  return contentsStatus;
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private void verifyExistingWorkingCopy() {
	final SvnGetStatus ops = svnOperationFactory.createGetStatus();
	ops.setSingleTarget(workingCopy);
	ops.setReportAll(logger.isDebugEnabled());
	final Collection<SvnStatus> statuses = tryRun(ops, new ArrayList<>(SvnStatus.class));
	
	for (final SvnStatus entry : statuses) {
		
		final SVNStatusType type = entry.getNodeStatus();
		final String filePath = entry.getPath().getPath();
		
		if (type != SVNStatusType.STATUS_NORMAL) {
			logger.error("Existing working copy is in an invalid state (maybe modified)! "
					+ "Pls fix manually or delete working copy at '" + workingCopy + "'.");
			throw new ConfigurationException(
					"Found entry with invalid status in working copy! "
					+ "Relative path: '" + filePath +"'. Status: '" + type + "'.");
		}
	}
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private String statusToString() throws IllegalArgumentException, SVNException, IOException
{
	StringBuilder sb = new StringBuilder();

	HashMap<SVNStatusType, ArrayList<String>> result = new HashMap<>();
	getSvn().getStatusClient().doStatus(localFolder_, SVNRevision.BASE, SVNDepth.INFINITY, false, true, true, false, new ISVNStatusHandler()
	{

		@Override
		public void handleStatus(SVNStatus status) throws SVNException
		{
			ArrayList<String> temp = result.get(status.getNodeStatus());
			if (temp == null)
			{
				temp = new ArrayList<>();
				result.put(status.getNodeStatus(), temp);
			}
			String path = status.getRepositoryRelativePath();
			if (path == null || path.isEmpty())
			{
				path = getPathRelativeToRoot(status.getFile());
				if (path.isEmpty())
				{
					path = "{repo root}";
				}
			}
			temp.add(path);
		}
	}, new ArrayList<String>());

	for (Entry<SVNStatusType, ArrayList<String>> x : result.entrySet())
	{
		sb.append(x.getKey().toString() + " - " + x.getValue() + eol);
	}
	return sb.toString();
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private Set<String> getLocallyModifiedFiles() throws IOException
{
	try
	{
		HashSet<String> result = new HashSet<>();
		getSvn().getStatusClient().doStatus(localFolder_, SVNRevision.BASE, SVNDepth.INFINITY, false, false, false, false, new ISVNStatusHandler()
		{

			@Override
			public void handleStatus(SVNStatus status) throws SVNException
			{
				if (status.getNodeStatus() == SVNStatusType.STATUS_MODIFIED || status.getNodeStatus() == SVNStatusType.STATUS_ADDED
						|| status.getNodeStatus() == SVNStatusType.STATUS_UNVERSIONED || status.getNodeStatus() == SVNStatusType.MERGED
						|| status.getNodeStatus() == SVNStatusType.STATUS_DELETED || status.getNodeStatus() == SVNStatusType.STATUS_REPLACED
						|| status.getNodeStatus() == SVNStatusType.MERGED)
				{
					result.add(getPathRelativeToRoot(status.getFile()));
				}
			}
		}, new ArrayList<String>());

		return result;
	}
	catch (Exception e)
	{
		log.error("Unexpected", e);
		throw new IOException("Internal error", e);
	}
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private static FileStatus convertSingleStatus(final SVNStatusType status, final FileStatus defaultConflictStatus) throws SVNException {
  if (status == null) {
    return FileStatus.UNKNOWN;
  }
  if (SVNStatusType.STATUS_UNVERSIONED.equals(status)) {
    return FileStatus.UNKNOWN;
  }
  else if (SVNStatusType.STATUS_MISSING.equals(status)) {
    return FileStatus.DELETED_FROM_FS;
  }
  else if (SVNStatusType.STATUS_EXTERNAL.equals(status)) {
    return SvnFileStatus.EXTERNAL;
  }
  else if (SVNStatusType.STATUS_OBSTRUCTED.equals(status)) {
    return SvnFileStatus.OBSTRUCTED;
  }
  else if (SVNStatusType.STATUS_IGNORED.equals(status)) {
    return FileStatus.IGNORED;
  }
  else if (SVNStatusType.STATUS_ADDED.equals(status)) {
    return FileStatus.ADDED;
  }
  else if (SVNStatusType.STATUS_DELETED.equals(status)) {
    return FileStatus.DELETED;
  }
  else if (SVNStatusType.STATUS_REPLACED.equals(status)) {
    return SvnFileStatus.REPLACED;
  }
  else if (status == SVNStatusType.STATUS_CONFLICTED) {
    return defaultConflictStatus;
  }
  else if (status == SVNStatusType.STATUS_MODIFIED) {
    return FileStatus.MODIFIED;
  }
  return FileStatus.NOT_CHANGED;
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
public static SVNStatusType convert(Status.Kind kind) {
  if (kind == null) return null;
  if (Status.Kind.added.equals(kind)) {
    return SVNStatusType.STATUS_ADDED;
  } else if (Status.Kind.conflicted.equals(kind)) {
    return SVNStatusType.STATUS_CONFLICTED;
  } else if (Status.Kind.deleted.equals(kind)) {
    return SVNStatusType.STATUS_DELETED;
  } else if (Status.Kind.external.equals(kind)) {
    return SVNStatusType.STATUS_EXTERNAL;
  } else if (Status.Kind.ignored.equals(kind)) {
    // 5
    return SVNStatusType.STATUS_IGNORED;
  } else if (Status.Kind.incomplete.equals(kind)) {
    return SVNStatusType.STATUS_INCOMPLETE;
  } else if (Status.Kind.merged.equals(kind)) {
    return SVNStatusType.STATUS_MERGED;
  } else if (Status.Kind.missing.equals(kind)) {
    return SVNStatusType.STATUS_MISSING;
  } else if (Status.Kind.modified.equals(kind)) {
    return SVNStatusType.STATUS_MODIFIED;
  } else if (Status.Kind.none.equals(kind)) {
    //10
    return SVNStatusType.STATUS_NONE;
  } else if (Status.Kind.normal.equals(kind)) {
    return SVNStatusType.STATUS_NORMAL;
  } else if (Status.Kind.obstructed.equals(kind)) {
    return SVNStatusType.STATUS_OBSTRUCTED;
  } else if (Status.Kind.replaced.equals(kind)) {
    return SVNStatusType.STATUS_REPLACED;
  } else if (Status.Kind.unversioned.equals(kind)) {
    return SVNStatusType.STATUS_UNVERSIONED;
  }
  return SVNStatusType.STATUS_NONE;
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
protected boolean handleInDescendants(final SVNEvent event) {
  if ((event.getAction() == SVNEventAction.UPDATE_UPDATE) && (event.getContentsStatus() == SVNStatusType.UNCHANGED) &&
        (event.getPropertiesStatus() == SVNStatusType.UNKNOWN)) {
      myText2 = SvnBundle.message("progres.text2.updated", event.getFile().getName());
    return true;
  } else if (event.getAction() == SVNEventAction.DELETE) {
    addFileToGroup(FileGroup.REMOVED_FROM_REPOSITORY_ID, event);
    myText2 = SvnBundle.message("progress.text2.deleted", event.getFile().getName());
    return true;
  }
  return false;
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
/**
 * folder that is going to keep merge info record should also be changed
 */
@Nullable
private void initMergeTarget() {
  final File mergeInfoHolder = myMerger.getMergeInfoHolder();
  if (mergeInfoHolder != null) {
    final SVNStatus svnStatus = SvnUtil.getStatus(myVcs, mergeInfoHolder);
    if ((svnStatus != null) && (SVNStatusType.STATUS_MODIFIED.equals(svnStatus.getPropertiesStatus()))) {

      myMergeTarget = FilePathImpl.create(mergeInfoHolder, mergeInfoHolder.isDirectory());
    }
  }
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
public FileData(String relativePath,
                String contents,
                SVNStatusType nodeStatus,
                SVNStatusType contentsStatus,
                SVNStatusType propertiesStatus,
                boolean isDir) {
  this(relativePath, contents, nodeStatus, contentsStatus, propertiesStatus, isDir, null);
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
private void applyFileData(final VirtualFile root, final TreeConflictData.FileData fileData) throws IOException {
  final File target = new File(root.getPath(), fileData.myRelativePath);

  // we dont apply properties changes fow now
  if (SVNStatusType.STATUS_MISSING.equals(fileData.myNodeStatus)) {
    // delete existing only from fs
    FileUtil.delete(target);
    return;
  } else if (SVNStatusType.STATUS_UNVERSIONED.equals(fileData.myNodeStatus)) {
    // create new unversioned
    createFile(root, fileData, target);
    return;
  } else if (SVNStatusType.STATUS_ADDED.equals(fileData.myNodeStatus)) {
    if (fileData.myCopyFrom != null) {
      myClientRunner.copy(root, fileData.myCopyFrom, fileData.myRelativePath);
      return;
    }
    createFile(root, fileData, target);
    myClientRunner.add(root, fileData.myRelativePath);
    return;
  } else if (SVNStatusType.STATUS_DELETED.equals(fileData.myNodeStatus)) {
    myClientRunner.delete(root, fileData.myRelativePath);
    return;
  } else if (SVNStatusType.STATUS_NORMAL.equals(fileData.myNodeStatus)) {
    if (SVNStatusType.STATUS_MODIFIED.equals(fileData.myContentsStatus)) {
      createFile(root, fileData, target);
      return;
    }
  }
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
/**
 * @see gov.va.isaac.interfaces.sync.ProfileSyncI#addUntrackedFiles(java.io.File)
 */
@Override
public void addUntrackedFiles() throws IllegalArgumentException, IOException
{
	log.info("Add Untracked files called");
	try
	{
		HashSet<String> result = new HashSet<>();
		HashSet<String> conflicts = new HashSet<>();
		getSvn().getStatusClient().doStatus(localFolder_, SVNRevision.BASE, SVNDepth.INFINITY, false, false, false, false, new ISVNStatusHandler()
		{

			@Override
			public void handleStatus(SVNStatus status) throws SVNException
			{
				if (status.getNodeStatus() == SVNStatusType.STATUS_UNVERSIONED)
				{
					result.add(getPathRelativeToRoot(status.getFile()));
				}
				else if (status.getNodeStatus() == SVNStatusType.STATUS_CONFLICTED)
				{
					conflicts.add(getPathRelativeToRoot(status.getFile()));
				}
			}
		}, new ArrayList<String>());

		//don't try to add conflict marker files
		for (String s : conflicts)
		{
			Iterator<String> toAdd = result.iterator();
			while (toAdd.hasNext())
			{
				String item = toAdd.next();
				if (item.equals(s + ".mine") || item.startsWith(s + ".r"))
				{
					toAdd.remove();
				}
			}
		}

		addFiles(result.toArray(new String[result.size()]));
	}
	catch (SVNException e)
	{
		log.error("Unexpected", e);
		throw new IOException("Internal error", e);
	}
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
public static FileStatus convertStatus(final SVNStatus status, final boolean noticeProperties) throws SVNException {
  if (status == null) {
    return FileStatus.UNKNOWN;
  }
  if (SvnVcs.svnStatusIsUnversioned(status)) {
    return FileStatus.UNKNOWN;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_MISSING)) {
    return FileStatus.DELETED_FROM_FS;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_EXTERNAL)) {
    return SvnFileStatus.EXTERNAL;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_OBSTRUCTED)) {
    return SvnFileStatus.OBSTRUCTED;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_IGNORED)) {
    return FileStatus.IGNORED;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_ADDED)) {
    return FileStatus.ADDED;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_DELETED)) {
    return FileStatus.DELETED;
  }
  else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_REPLACED)) {
    return SvnFileStatus.REPLACED;
  }
  else if (status.getContentsStatus() == SVNStatusType.STATUS_CONFLICTED ||
           noticeProperties && status.getPropertiesStatus() == SVNStatusType.STATUS_CONFLICTED) {
    if (status.getContentsStatus() == SVNStatusType.STATUS_CONFLICTED &&
        noticeProperties && status.getPropertiesStatus() == SVNStatusType.STATUS_CONFLICTED) {
      return FileStatus.MERGED_WITH_BOTH_CONFLICTS;
    } else if (status.getContentsStatus() == SVNStatusType.STATUS_CONFLICTED) {
      return FileStatus.MERGED_WITH_CONFLICTS;
    }
    return FileStatus.MERGED_WITH_PROPERTY_CONFLICTS;
  }
  else if (status.getContentsStatus() == SVNStatusType.STATUS_MODIFIED ||
           noticeProperties && status.getPropertiesStatus() == SVNStatusType.STATUS_MODIFIED) {
    return FileStatus.MODIFIED;
  }
  else if (status.isSwitched()) {
    return FileStatus.SWITCHED;
  }
  else if (status.isCopied()) {
    return FileStatus.ADDED;
  }
  return FileStatus.NOT_CHANGED;
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
public static FileStatus convertPropertyStatus(final SVNStatusType status) throws SVNException {
  return convertSingleStatus(status, FileStatus.MERGED_WITH_PROPERTY_CONFLICTS);
}
 

import org.tmatesoft.svn.core.wc.SVNStatusType; //导入依赖的package包/类
@Override
protected void updateStatus(Attributes attributes, PortableStatus status, SVNLockWrapper lock) throws SAXException {
  final String props = attributes.getValue("props");
  assertSAX(props != null);
  final SVNStatusType propertiesStatus = StatusCallbackConvertor.convert(org.apache.subversion.javahl.types.Status.Kind.valueOf(props));
  status.setPropertiesStatus(propertiesStatus);
  final String item = attributes.getValue("item");
  assertSAX(item != null);
  final SVNStatusType contentsStatus = StatusCallbackConvertor.convert(org.apache.subversion.javahl.types.Status.Kind.valueOf(item));
  status.setContentsStatus(contentsStatus);

  if (SVNStatusType.STATUS_CONFLICTED.equals(propertiesStatus) || SVNStatusType.STATUS_CONFLICTED.equals(contentsStatus)) {
    status.setIsConflicted(true);
  }

  // optional
  final String locked = attributes.getValue("wc-locked");
  if (locked != null && Boolean.parseBoolean(locked)) {
    status.setIsLocked(true);
  }
  final String copied = attributes.getValue("copied");
  if (copied != null && Boolean.parseBoolean(copied)) {
    status.setIsCopied(true);
  }
  final String treeConflicted = attributes.getValue("tree-conflicted");
  if (treeConflicted != null && Boolean.parseBoolean(treeConflicted)) {
    status.setIsConflicted(true);
  }

  final String switched = attributes.getValue("switched");
  if (switched != null && Boolean.parseBoolean(switched)) {
    status.setIsSwitched(true);
  }

  final String revision = attributes.getValue("revision");
  if (! StringUtil.isEmptyOrSpaces(revision)) {
    try {
      final long number = Long.parseLong(revision);
      status.setRevision(SVNRevision.create(number));
    } catch (NumberFormatException e) {
      throw new SAXException(e);
    }
  }
}