Application: gvSIG desktop » Library: org.gvsig.tools

import org.gvsig.tools.util.FileTools;

package org.gvsig.tools.util;

import java.io.File;

import org.apache.commons.io.FilenameUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class FileTools {

    private static Logger logger = LoggerFactory.getLogger(FileTools.class);

	public static File relativizeFile(File rootFolder, File file) {

		if (rootFolder == null) {

			return file;

		}

		if (file == null) {

			return null;

		}

		boolean isDir = false;

		// isDir = file.isDirectory();

		isDir = rootFolder.isDirectory();

		String basePath = rootFolder.getAbsolutePath();

                if( basePath == null ) {

                    logger.warn("Can't get absolute path, no relativize file '"+rootFolder.toString()+"'.");

                    return file;

                }

		String targetPath = FilenameUtils.normalize(file.getPath());

                if( targetPath == null ) {

                    logger.warn("Can't normalize path, no relativize file '"+file.getAbsolutePath()+"'.");

                    return file;

                }

		String pathSeparator = File.separator;

		// We need the -1 argument to split to make sure we get a trailing

		// "" token if the base ends in the path separator and is therefore

		// a directory. We require directory paths to end in the path

		// separator -- otherwise they are indistinguishable from files.

                String pathSeparatorQuoted = Pattern_quote(pathSeparator);

		String[] base = basePath.split(pathSeparatorQuoted, -1);

		String[] target = targetPath.split(pathSeparatorQuoted, 0);

		// First get all the common elements. Store them as a string,

		// and also count how many of them there are.

		String common = "";

		int commonIndex = 0;

		for (int i = 0; i < target.length && i < base.length; i++) {

			if (target[i].equals(base[i])) {

				common += target[i] + pathSeparator;

				commonIndex++;

			} else

				break;

		}

		if (commonIndex == 0) {

			// Whoops -- not even a single common path element. This most

			// likely indicates differing drive letters, like C: and D:.

			// These paths cannot be relativized. Return the target path.

			return file;

			// This should never happen when all absolute paths

			// begin with / as in *nix.

		}

		String relative = "";

		if (base.length == commonIndex) {

			// Comment this out if you prefer that a relative path not start

			// with ./

			relative = "." + pathSeparator;

		} else {

			int numDirsUp = base.length - commonIndex - (isDir ? 0 : 1); 

			// only subtract 1 if it is a file.

			// The number of directories we have to backtrack is the length of

			// the base path MINUS the number of common path elements, minus

			// one because the last element in the path isn't a directory.

			for (int i = 1; i <= (numDirsUp); i++) {

				relative += ".." + pathSeparator;

			}

		}

		// if we are comparing directories then we

		if (targetPath.length() > common.length()) {

			// it's OK, it isn't a directory

			relative += targetPath.substring(common.length());

		}

		return new File(relative);

	}

	public static File derelativizeFile(File rootFolder, File file ) {

		if(rootFolder == null || file == null){

			return file;

		}

		if (file.isAbsolute()) {

			return file;

		}

		File f = new File(rootFolder, file.getPath()).getAbsoluteFile();

		String targetPath = FilenameUtils.normalize(f.getPath());

		return new File(targetPath);

	}

    public static boolean isInDifferentDrive(File rootFolder, File file) {

        if (rootFolder == null) {

            return false;

        }

        if (file == null) {

            return false;

        }

        String basePath = rootFolder.getAbsolutePath();

        String targetPath = file.getPath();

        String pathSeparator = File.separator;

        // We need the -1 argument to split to make sure we get a trailing

        // "" token if the base ends in the path separator and is therefore

        // a directory. We require directory paths to end in the path

        // separator -- otherwise they are indistinguishable from files.

        String[] base = basePath.split(Pattern_quote(pathSeparator), -1);

        String[] target = targetPath.split(Pattern_quote(pathSeparator), 0);

        /*

         * If first component is different then they are different

         * drives. In Unix-type file systems, the first for both

         * should be "" so this will not happen

         */

        return !target[0].equals(base[0]);

    }

    private static String Pattern_quote(String str) {

        int eInd = str.indexOf("\\E");

        if (eInd < 0) {

            // No need to handle backslashes.

            return "\\Q" + str + "\\E";

        }

        StringBuffer sb = new StringBuffer(str.length() + 16);

        sb.append("\\Q"); // start quote

        int pos = 0;

        do {

        // A backslash is quoted by another backslash;

            // 'E' is not needed to be quoted.

            sb.append(str.substring(pos, eInd))

                    .append("\\E" + "\\\\" + "E" + "\\Q");

            pos = eInd + 2;

        } while ((eInd = str.indexOf("\\E", pos)) >= 0);

        sb.append(str.substring(pos, str.length()))

                .append("\\E"); // end quote

        return sb.toString();

    }

}