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

package org.gvsig.tools.persistence.impl;

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);

        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);

        }

        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);

        }

    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();

    }

}