/********************************************************************************

 * Copyright (c) 2008 IBM Corporation. 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

 * 

 * <p>

 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as

 * part of a work in progress. There is no guarantee that this API will

 * work or that it will remain the same. Please do not use this API without

 * consulting with the <Your Team Name> team.

 * </p>

 *  

 * 

 * Contributors:

 * Rupen Mardirossian (IBM)	[221556] - Create HostPath.java based on org.eclipse.core.runtime.Path (code taken from Path class and modified).

 ********************************************************************************/

package org.eclipse.rse.internal.services;

import org.eclipse.core.runtime.Assert;

import org.eclipse.rse.services.clientserver.PathUtility;

public class HostPath implements IHostPath, Cloneable {

	protected char separator;

	/** The path segments */

	private String[] segments;

	/** Constant value indicating if the current platform is Windows */

	private static final boolean WINDOWS = java.io.File.separatorChar == '\\';

	/** Constant value indicating no segments */

	private static final String[] NO_SEGMENTS = new String[0];

	/** The device id string. May be null if there is no device. */

	private String device = null;

	/** Constant empty string value. */

	private static final String EMPTY_STRING = ""; //$NON-NLS-1$

	/** 

	 * Constructs a new path from the given string path.

	 * The string path must represent a valid file system path

	 * on the local/remote file system. 

	 * segment delimiters (separators) are determined, and any

	 * segment and device delimiters for the local file system are

	 * also respected (such as colon (':') and backslash ('\') on some file systems).

	 *

	 * @param fullPath the string path

	 */

	public HostPath(String fullPath) {

		Assert.isNotNull(fullPath);

		String devicePart = null;

		String stringSep = PathUtility.getSeparator(fullPath);

		if (stringSep.equals("/"))  //$NON-NLS-1$

		{

			this.separator = '/';

		} 

		else if (stringSep.equals("\\")) //$NON-NLS-1$

		{

			this.separator = '\\';

		}

		if (WINDOWS) {

			//extract device

			int i = fullPath.indexOf(DEVICE_SEPARATOR);

			if (i != -1) {

				//remove leading slash from device part to handle output of URL.getFile()

				int start = fullPath.charAt(0) == this.separator ? 1 : 0;

				devicePart = fullPath.substring(start, i + 1);

				fullPath = fullPath.substring(i + 1, fullPath.length());

			}

		}

		initialize(devicePart, fullPath);

	}

	/* 

	 * Private constructor.

	 */

	private HostPath(String device, String[] segments, char separator) {

		// no segment validations are done for performance reasons	

		this.segments = segments;

		this.device = device;

		this.separator = separator;

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * Clones this object.

	 */

	public Object clone() {

		try {

			return super.clone();

		} catch (CloneNotSupportedException e) {

			return null;

		}

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * Compares objects for equality.

	 */

	public boolean equals(Object obj) {

		if (this == obj)

			return true;

		if (!(obj instanceof HostPath))

			return false;

		HostPath target = (HostPath) obj;

		String[] targetSegments = target.segments;

		int i = segments.length;

		//check segment count

		if (i != targetSegments.length)

			return false;

		//check segments in reverse order - later segments more likely to differ

		while (--i >= 0)

			if (!segments[i].equals(targetSegments[i]))

				return false;

		//check device last (least likely to differ)

		return device == target.device || (device != null && device.equals(target.device));

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/**

	 * Computes the segment array for the given canonicalized path.

	 */

	private String[] computeSegments(String path) {

		// performance sensitive --- avoid creating garbage

		int segmentCount = computeSegmentCount(path);

		if (segmentCount == 0)

			return NO_SEGMENTS;

		String[] newSegments = new String[segmentCount];

		int len = path.length();

		// check for initial slash

		int firstPosition = (path.charAt(0) == separator) ? 1 : 0;

		// check for UNC

		if (firstPosition == 1 && len > 1 && (path.charAt(1) == separator))

			firstPosition = 2;

		int lastPosition = (path.charAt(len - 1) != separator) ? len - 1 : len - 2;

		// for non-empty paths, the number of segments is 

		// the number of slashes plus 1, ignoring any leading

		// and trailing slashes

		int next = firstPosition;

		for (int i = 0; i < segmentCount; i++) {

			int start = next;

			int end = path.indexOf(separator, next);

			if (end == -1) {

				newSegments[i] = path.substring(start, lastPosition + 1);

			} else {

				newSegments[i] = path.substring(start, end);

			}

			next = end + 1;

		}

		return newSegments;

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * Returns the size of the string that will be created by toString or toOSString.

	 */

	private int computeLength() {

		int length = 0;

		if (device != null)

			length += device.length();

		//add the segment lengths

		int max = segments.length;

		if (max > 0) {

			for (int i = 0; i < max; i++) {

				length += segments[i].length();

			}

			//add the separator lengths

			length += max;

		}

		return length;

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * Returns the number of segments in the given path

	 */

	private int computeSegmentCount(String path) {

		int len = path.length();

		if (len == 0 || (len == 1 && path.charAt(0) == separator)) {

			return 0;

		}

		int count = 1;

		int prev = -1;

		int i;

		while ((i = path.indexOf(separator, prev + 1)) != -1) {

			if (i != prev + 1 && i != len) {

				++count;

			}

			prev = i;

		}

		if (path.charAt(len - 1) == separator) {

			--count;

		}

		return count;

	}

	/*

	 * @see IHostPath#getDevice

	 */

	public String getDevice() {

		return device;

	}

	/*

	 * Initialize the current path with the given string.

	 */

	private void initialize(String device, String path) 

	{	

		this.device = device;

		this.segments = computeSegments(path);

	}

	/*

	 * return the number of segments in the path

	 */

	public int segmentCount() {

		return segments.length;

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * @see IHostPath#removeFirstSegments(int)

	 */

	public IHostPath removeFirstSegments(int count) {

		if (count == 0)

			return this;

		if (count >= segments.length) {

			return new HostPath(device, NO_SEGMENTS, separator);

		}

		Assert.isLegal(count > 0);

		int newSize = segments.length - count;

		String[] newSegments = new String[newSize];

		System.arraycopy(this.segments, count, newSegments, 0, newSize);

		//result is always a relative path

		return new HostPath(device, newSegments, separator);

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * @see IHostPath#removeLastSegments(int)

	 */

	public IHostPath removeLastSegments(int count) {

		if (count == 0)

			return this;

		if (count >= segments.length) {

			//result will have no trailing separator

			return new HostPath(device, NO_SEGMENTS, separator);

		}

		Assert.isLegal(count > 0);

		int newSize = segments.length - count;

		String[] newSegments = new String[newSize];

		System.arraycopy(this.segments, 0, newSegments, 0, newSize);

		return new HostPath(device, newSegments, separator);

	}

	/* 

	 * return the segment at specified location in array

	 */

	public String segment(int index) {

		if (index >= segments.length)

			return null;

		return segments[index];

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * return segments of the path in an array 

	 */

	public String[] segments() {

		String[] segmentCopy = new String[segments.length];

		System.arraycopy(segments, 0, segmentCopy, 0, segments.length);

		return segmentCopy;

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/*

	 * @see IHostPath#setDevice(String)

	 */

	public IHostPath setDevice(String value) {

		if (value != null) {

			Assert.isTrue(value.indexOf(IHostPath.DEVICE_SEPARATOR) == (value.length() - 1), "Last character should be the device separator"); //$NON-NLS-1$

		}

		//return the receiver if the device is the same

		if (value == device || (value != null && value.equals(device)))

			return this;

		return new HostPath(value, this.segments, this.separator);

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * @see IHostPath#toString()

	 */

	public String toString() {

		int resultSize = computeLength();

		if (resultSize <= 0)

			return EMPTY_STRING;

		char[] result = new char[resultSize];

		int offset = 0;

		if (device != null) {

			int size = device.length();

			device.getChars(0, size, result, offset);

			offset += size;

			result[offset++] = separator;

		}

		int len = segments.length - 1;

		if (len >= 0) {

			//append all but the last segment, with separators

			for (int i = 0; i < len; i++) {

				int size = segments[i].length();

				segments[i].getChars(0, size, result, offset);

				offset += size;

				result[offset++] = separator;

			}

			//append the last segment

			int size = segments[len].length();

			segments[len].getChars(0, size, result, offset);

			offset += size;

		}

		return new String(result);

	}

	//----------------------------------------------------------------------

	// <taken from org.eclipse.core.runtime.Path and modified (Copyright IBM)>

	//----------------------------------------------------------------------

	/* 

	 * @see IHostPath#uptoSegment(int)

	 */

	public IHostPath uptoSegment(int count) {

		if (count == 0)

			return new HostPath(device, NO_SEGMENTS, separator);

		if (count >= segments.length)

			return this;

		Assert.isTrue(count > 0, "Invalid parameter to Path.uptoSegment"); //$NON-NLS-1$

		String[] newSegments = new String[count];

		System.arraycopy(segments, 0, newSegments, 0, count);

		return new HostPath(device, newSegments, separator);

	}

}

/********************************************************************************

 * Copyright (c) 2008 IBM Corporation. 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

 * 

 * <p>

 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as

 * part of a work in progress. There is no guarantee that this API will

 * work or that it will remain the same. Please do not use this API without

 * consulting with the <Your Team Name> team.

 * </p>

 *  

 * 

 * Contributors:

 * Rupen Mardirossian (IBM)	[221556] - Create IHostPath.java based on org.eclipse.core.runtime.IPath (code taken from IPath interface and modified).

 ********************************************************************************/

package org.eclipse.rse.internal.services;

/**

 * This interface represents a host path.

 */

public interface IHostPath extends Cloneable {

	/** 

	 * Device separator character constant ":" used in paths.

	 */

	public static final char DEVICE_SEPARATOR = ':';

	/**

	 * Returns a copy of this path.

	 *

	 * @return the cloned path

	 */

	public Object clone();

	/**

	 * Returns whether this path equals the given object.

	 * <p>

	 * Equality for paths is defined to be: same sequence of segments and same device.

	 * Paths are not generally considered equal to objects other than paths.

	 * </p>

	 *

	 * @param obj the other object

	 * @return <code>true</code> if the paths are equivalent,

	 *    and <code>false</code> if they are not

	 */

	public boolean equals(Object obj);

	/**

	 * Returns the device id for this path, or <code>null</code> if this

	 * path has no device id. Note that the result will end in ':'.

	 *

	 * @return the device id, or <code>null</code>

	 * @see #setDevice(String)

	 */

	public String getDevice();

	/**

	 * Returns a copy of this path with the given number of segments

	 * removed from the beginning. The device id is preserved. 

	 * The number must be greater or equal zero.

	 * If the count is zero, this path is returned.

	 * The resulting path will always be a relative path with respect

	 * to this path.  If the number equals or exceeds the number

	 * of segments in this path, an empty relative path is returned.

	 *

	 * @param count the number of segments to remove

	 * @return the new path

	 */

	public IHostPath removeFirstSegments(int count);

	/**

	 * Returns a copy of this path with the given number of segments

	 * removed from the end. The device id is preserved.

	 * The number must be greater or equal zero.

	 * If the count is zero, this path is returned.

	 * If the number equals or exceeds the number

	 * of segments in this path, a path with no segments is returned.

	 * </p>

	 *

	 * @param count the number of segments to remove

	 * @return the new path

	 */

	public IHostPath removeLastSegments(int count);

	/**

	 * Returns the specified segment of this path, or

	 * <code>null</code> if the path does not have such a segment.

	 *

	 * @param index the 0-based segment index

	 * @return the specified segment, or <code>null</code> 

	 */

	public String segment(int index);

	/**

	 * Returns the number of segments in this path.

	 * <p> 

	 * Note that both root and empty paths have 0 segments.

	 * </p>

	 *

	 * @return the number of segments

	 */

	public int segmentCount();

	/**

	 * Returns the segments in this path in order.

	 *

	 * @return an array of string segments

	 */

	public String[] segments();

	/**

	 * Returns a new path which is the same as this path but with 

	 * the given device id.  The device id must end with a ":".

	 * A device independent path is obtained by passing <code>null</code>.

	 * <p>

	 * For example, "C:" and "Server/Volume:" are typical device ids.

	 * </p>

	 *

	 * @param device the device id or <code>null</code>

	 * @return a new path

	 * @see #getDevice()

	 */

	public IHostPath setDevice(String device);

	/**

	 * Returns a string representation of this path, including its

	 * device id.  

	 * <p>

	 * Example result strings (without and with device id):

	 * <pre>

	 * "/foo/bar.txt"

	 * "bar.txt"

	 * "/foo/"

	 * "foo/"

	 * ""

	 * "/"

	 * "C:/foo/bar.txt"

	 * "C:bar.txt"

	 * "C:/foo/"

	 * "C:foo/"

	 * "C:"

	 * "C:/"

	 * </pre>

	 * This string is suitable for passing to <code>Path(String)</code>.

	 * </p>

	 *

	 * @return a string representation of this path

	 * @see HostPath

	 */

	public String toString();

	/**

	 * Returns a copy of this path truncated after the

	 * given number of segments. The number must not be negative.

	 * The device id is preserved.

	 * <p>

	 * Copying up to segment zero simply means making an copy with

	 * no path segments.

	 * </p>

	 *

	 * @param count the segment number at which to truncate the path

	 * @return the new path

	 */

	public IHostPath uptoSegment(int count);

}