/*******************************************************************************
* Copyright (c) 2000, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.internal.ccvs.core.util;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.util.NLS;
import org.eclipse.team.internal.ccvs.core.*;
import org.eclipse.team.internal.ccvs.core.client.Session;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.core.syncinfo.FolderSyncInfo;
import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
/**
* Unsorted static helper-methods
*/
public class Util {
/**
* Return the last segment of the given path
* @param path
* @return String
*/
public static String getLastSegment(String path) {
int index = path.lastIndexOf(Session.SERVER_SEPARATOR);
if (index == -1) {
return path;
}
if (index == path.length() - 1) {
return getLastSegment(path.substring(0, index));
}
return path.substring(index + 1);
}
/**
* Return the the given path with the last segment removed
* @param path
* @return String
*/
public static String removeLastSegment(String path) {
int index = path.lastIndexOf(Session.SERVER_SEPARATOR);
if (index == -1)
return ""; //$NON-NLS-1$
else
return path.substring(0, index);
}
/**
* Return the path without a trailing /
* @param path
* @return String
*/
public static String asPath(String path) {
if (path.endsWith(Session.SERVER_SEPARATOR)) {
return path.substring(0, path.length() - Session.SERVER_SEPARATOR.length());
}
return path;
}
/*
* *
* Get the extention of the path of resource
* relative to the path of root
*
* @throws CVSException if root is not a root-folder of resource
*/
public static String getRelativePath(String rootName, String resourceName)
throws CVSException {
if (!resourceName.startsWith(rootName) || rootName.length() > resourceName.length()) {
throw new CVSException(CVSMessages.Util_Internal_error__resource_does_not_start_with_root_3);
}
// Otherwise we would get an ArrayOutOfBoundException
// in case of two equal Resources
if (rootName.length() == resourceName.length()) {
return ""; //$NON-NLS-1$
}
// Remove leading slash if there is one
String result = resourceName.substring(rootName.length());
if (result.startsWith("/")) { //$NON-NLS-1$
result = result.substring(1);
}
return result;
}
/**
* Append the prefix and suffix to form a valid CVS path.
*/
public static String appendPath(String prefix, String suffix) {
if (prefix.length() == 0 || prefix.equals(Session.CURRENT_LOCAL_FOLDER)) {
return suffix;
} else if (prefix.endsWith(Session.SERVER_SEPARATOR)) {
if (suffix.startsWith(Session.SERVER_SEPARATOR))
return prefix + suffix.substring(1);
else
return prefix + suffix;
} else if (suffix.startsWith(Session.SERVER_SEPARATOR))
return prefix + suffix;
else
return prefix + Session.SERVER_SEPARATOR + suffix;
}
public static void logError(String message, Throwable throwable) {
CVSProviderPlugin.log(IStatus.ERROR, message, throwable);
}
/**
* If the number of segments in the relative path of <code>resource</code> to <code>root</code> is
* greater than <code>split</code> then the returned path is truncated to <code>split</code> number
* of segments and '...' is shown as the first segment of the path.
*/
public static String toTruncatedPath(ICVSResource resource, ICVSFolder root, int split) {
try {
String stringPath = resource.getRelativePath(root);
if (stringPath.equals(Session.CURRENT_LOCAL_FOLDER)) {
return resource.getName();
}
String truncatedPath = toTruncatedPath(stringPath, split);
return truncatedPath;
} catch(CVSException e) {
return resource.getName();
}
}
public static String toTruncatedPath(String stringPath, int split) {
// Search backwards until split separators are found
int count = 0;
int index = stringPath.length();
while (count++ < split && index != -1) {
index = stringPath.lastIndexOf(Session.SERVER_SEPARATOR, index - 1);
}
if (index == -1) {
return stringPath;
} else {
return NLS.bind(CVSMessages.Util_truncatedPath, new String[] { stringPath.substring(index) });
}
}
/**
* Helper method that will time out when making a socket connection.
* This is required because there is no way to provide a timeout value
* when creating a socket and in some instances, they don't seem to
* timeout at all.
*/
public static Socket createSocket(final String host, final int port, IProgressMonitor monitor) throws UnknownHostException, IOException {
int timeout = CVSProviderPlugin.getPlugin().getTimeout();
if (timeout == 0) timeout = CVSProviderPlugin.DEFAULT_TIMEOUT;
ResponsiveSocketFactory factory = new ResponsiveSocketFactory(monitor, timeout);
return factory.createSocket(host, port);
}
/**
* Helper method that will time out when running an external command.
* This is required because there is no way to provide a timeout value
* when executing an external command and in some instances, they don't seem to
* timeout at all.
*/
public static Process createProcess(final String[] command, IProgressMonitor monitor) throws IOException {
// Start a thread to execute the command and get a handle to the process
final Process[] process = new Process[] { null };
final Exception[] exception = new Exception[] {null };
final Thread thread = new Thread(new Runnable() {
public void run() {
try {
Process newProcess = Runtime.getRuntime().exec(command);
synchronized (process) {
if (Thread.interrupted()) {
// we we're either cancelled or timed out so just destroy the process
newProcess.destroy();
} else {
process[0] = newProcess;
}
}
} catch (IOException e) {
exception[0] = e;
}
}
});
thread.start();
// Wait the appropriate number of seconds
int timeout = CVSProviderPlugin.getPlugin().getTimeout();
if (timeout == 0) timeout = CVSProviderPlugin.DEFAULT_TIMEOUT;
for (int i = 0; i < timeout; i++) {
try {
// wait for the thread to complete or 1 second, which ever comes first
thread.join(1000);
} catch (InterruptedException e) {
// I think this means the thread was interupted but not necessarily timed out
// so we don't need to do anything
}
synchronized (process) {
// if the user cancelled, clean up before preempting the operation
if (monitor.isCanceled()) {
if (thread.isAlive()) {
thread.interrupt();
}
if (process[0] != null) {
process[0].destroy();
}
// this method will throw the proper exception
Policy.checkCanceled(monitor);
}
}
}
// If the thread is still running (i.e. we timed out) signal that it is too late
synchronized (process) {
if (thread.isAlive()) {
thread.interrupt();
}
}
if (exception[0] != null) {
throw (IOException)exception[0];
}
if (process[0] == null) {
throw new InterruptedIOException(NLS.bind(CVSMessages.Util_processTimeout, new String[] { command[0] }));
}
return process[0];
}
public static String[] parseIntoSubstrings(String string, String delimiter) {
List result = new ArrayList();
int start = 0;
int index = string.indexOf(delimiter);
String next;
while (index != -1) {
next = string.substring(start, index);
result.add(next);
start = index + 1;
index = string.indexOf(delimiter, start);
}
if (start >= string.length()) {
next = "";//$NON-NLS-1$
} else {
next = string.substring(start);
}
result.add(next);
return (String[]) result.toArray(new String[result.size()]);
}
/**
* Return the substring at the given index (starting at 0) where each
* element is delimited by the provided delimiter.
*
* @param bytes
* @param delimiter
* @param index
* @param includeRest
* @return String
*/
public static String getSubstring(byte[] bytes, byte delimiter, int index, boolean includeRest) {
byte[] bytesForSlot = getBytesForSlot(bytes, delimiter, index, includeRest);
if (bytesForSlot == null) {
return null;
}
return new String(bytesForSlot);
}
/**
* Return the offset the the Nth delimeter from the given start index.
* @param bytes
* @param delimiter
* @param start
* @param n
* @return int
*/
public static int getOffsetOfDelimeter(byte[] bytes, byte delimiter, int start, int n) {
int count = 0;
for (int i = start; i < bytes.length; i++) {
if (bytes[i] == delimiter) count++;
if (count == n) return i;
}
// the Nth delimeter was not found
return -1;
}
/**
* Method getBytesForSlot.
* @param syncBytes
* @param SEPARATOR_BYTE
* @param i
* @param b
* @return byte[]
*/
public static byte[] getBytesForSlot(byte[] bytes, byte delimiter, int index, boolean includeRest) {
// Find the starting index
int start;
if (index == 0) {
// make start -1 so that end determination will start at offset 0.
start = -1;
} else {
start = getOffsetOfDelimeter(bytes, delimiter, 0, index);
if (start == -1) return null;
}
// Find the ending index
int end = getOffsetOfDelimeter(bytes, delimiter, start + 1, 1);
// Calculate the length
int length;
if (end == -1 || includeRest) {
length = bytes.length - start - 1;
} else {
length = end - start - 1;
}
byte[] result = new byte[length];
System.arraycopy(bytes, start + 1, result, 0, length);
return result;
}
/**
* Method equals.
* @param syncBytes
* @param oldBytes
* @return boolean
*/
public static boolean equals(byte[] syncBytes, byte[] oldBytes) {
if (syncBytes == null || oldBytes == null) return syncBytes == oldBytes;
if (syncBytes.length != oldBytes.length) return false;
for (int i = 0; i < oldBytes.length; i++) {
if (oldBytes[i] != syncBytes[i]) return false;
}
return true;
}
/**
* Workaround a CVS bug where a CVS Folder with no immediately contained files has an incorrect
* Tag type stored in the TAG file. In this case, the tag type is always BRANCH (Tv1)
*
* The fix is for folders with no files, use the tag type for the containing project. Since projects almost
* always have files the TAG file is usually correct.
*
* For the case where the folder tag name does not match the project tag name we can not do much so we just
* return the folder tag which will currently always be a branch.
*
* @param resource The IResource being tested. Can not be null.
* @param tag The CVSTag as reported by CVS for the IResource. May be null.
* @return CVSTag The corrected tag for the resource. May be null.
*/
public static CVSTag getAccurateFolderTag(IResource resource, CVSTag tag) {
// Determine if the folder contains files as immediate children.
if (resource.getType() != IResource.FOLDER) {
return tag;
}
IResource[] members = null;
try {
members = ((IFolder) resource).members();
} catch (CoreException e1) {
return tag;
}
for (int i = 0; i < members.length; i++) {
if (members[i].getType() == IResource.FILE) {
return tag;
}
}
// Folder contains no files so this may not really be a branch.
// Make the type the same as the project tag type if both are the same tag name.
IProject project = resource.getProject();
if (project == null) {
return tag;
}
ICVSFolder projectFolder = CVSWorkspaceRoot.getCVSFolderFor(project);
FolderSyncInfo projectSyncInfo;
try {
projectSyncInfo = projectFolder.getFolderSyncInfo();
} catch (CVSException e) {
return tag;
}
if (projectSyncInfo == null) {
return tag;
}
CVSTag projectTag = projectSyncInfo.getTag();
if (projectTag != null && projectTag.getName().equals(tag.getName())) {
return projectTag;
} else {
return tag;
}
}
/**
* Workaround for CVS "bug" where CVS ENTRIES file does not contain correct
* Branch vs. Version info. Entries files always record a Tv1 so all entries would
* appear as branches.
*
* By comparing the revision number to the tag name
* you can determine if the tag is a branch or version.
*
* @param cvsResource the resource to test. Must nut be null.
* @return the correct cVSTag. May be null.
*/
public static CVSTag getAccurateFileTag(ICVSResource cvsResource) throws CVSException {
CVSTag tag = null;
ResourceSyncInfo info = cvsResource.getSyncInfo();
if(info != null) {
tag = info.getTag();
}
FolderSyncInfo parentInfo = cvsResource.getParent().getFolderSyncInfo();
CVSTag parentTag = null;
if(parentInfo != null) {
parentTag = parentInfo.getTag();
}
if(tag != null) {
if(tag.getName().equals(info.getRevision())) {
tag = new CVSTag(tag.getName(), CVSTag.VERSION);
} else if(parentTag != null){
tag = new CVSTag(tag.getName(), parentTag.getType());
}
}
return tag;
}
/**
* Return the fullest path that we can obtain for the given resource
* @param resource
* @return
*/
public static String getFullestPath(ICVSResource resource) {
IResource local = resource.getIResource();
if (local != null) {
return local.getFullPath().toString();
}
try {
String remotePath = resource.getRepositoryRelativePath();
if (remotePath != null) {
return remotePath;
}
} catch (CVSException e) {
// Ignore and try the next method;
}
return resource.getName();
}
public static String getVariablePattern(String pattern, String variableName) {
return "(" + variableName + ":" + pattern + ":" + variableName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
}
/**
* @param localRevision
* @return
*/
public static int[] convertToDigits(String localRevision) {
try {
String digitStrings[] = localRevision.split("\\."); //$NON-NLS-1$
int[] digits = new int[digitStrings.length];
for (int i = 0; i < digitStrings.length; i++) {
String digitString = digitStrings[i];
digits[i] = Integer.parseInt(digitString);
}
return digits;
} catch (NumberFormatException e) {
CVSProviderPlugin.log(CVSException.wrapException(e));
return new int[0];
}
}
public static String toTruncatedPath(ICVSStorage file, ICVSFolder localRoot, int i) {
if (file instanceof ICVSResource) {
return toTruncatedPath((ICVSResource)file, localRoot, i);
}
return file.getName();
}
/**
* If the status/log returns that the file is in the Attic, then remove the
* Attic segment. This is because files added to a branch that are not in
* the main trunk (HEAD) are added to the Attic but cvs does magic on
* update to put them in the correct location.
* (e.g. /project/Attic/file.txt -> /project/file.txt)
*/
public static String removeAtticSegment(String path) {
int lastSeparator = path.lastIndexOf(Session.SERVER_SEPARATOR);
if (lastSeparator == -1) return path;
int secondLastSeparator = path.lastIndexOf(Session.SERVER_SEPARATOR, lastSeparator - 1);
if (secondLastSeparator == -1) return path;
String secondLastSegment = path.substring(secondLastSeparator + 1, lastSeparator);
if (secondLastSegment.equals("Attic")) { //$NON-NLS-1$
return path.substring(0, secondLastSeparator) + path.substring(lastSeparator);
}
return path;
}
/**
* Flatten the text in the multiline comment
*/
public static String flattenText(String string) {
StringBuffer buffer = new StringBuffer(string.length() + 20);
boolean skipAdjacentLineSeparator = true;
for (int i = 0; i < string.length(); i++) {
char c = string.charAt(i);
if (c == '\r' || c == '\n') {
if (!skipAdjacentLineSeparator)
buffer.append(Session.SERVER_SEPARATOR);
skipAdjacentLineSeparator = true;
} else {
buffer.append(c);
skipAdjacentLineSeparator = false;
}
}
return buffer.toString();
}
}
|