PathManagerUtils.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.model.io;

import java.io.File;
import java.io.IOException;
import java.util.regex.Pattern;
import net.sf.gridarta.utils.StringUtils;
import org.jetbrains.annotations.NotNull;

public class PathManagerUtils {

    @NotNull
    private static final Pattern PATTERN_REDUNDANT = Pattern.compile("[^/]+/\\.\\./");

    @NotNull
    private static final Pattern PATTERN_SLASHES = Pattern.compile("//*");

    private PathManagerUtils() {
    }

    @NotNull
    public static String getMapPath(@NotNull final File file, @NotNull final File baseDir) {
        @NotNull final String mapDirName = baseDir.getPath();
        String mapPath = file.getPath().replace('\\', '/');
        if (mapPath.startsWith(mapDirName)) {
            mapPath = mapPath.substring(mapDirName.length());
        }
        if (mapPath.startsWith(new File(mapDirName).getAbsolutePath())) {
            mapPath = mapPath.substring(new File(mapDirName).getAbsolutePath().length());
        }
        try {
            if (mapPath.startsWith(new File(mapDirName).getCanonicalPath())) {
                mapPath = mapPath.substring(new File(mapDirName).getCanonicalPath().length());
            }
        } catch (final IOException ignored) {
            // ignore
        }
        mapPath = mapPath.replace('\\', '/');
        return mapPath;
    }

    public static boolean isAbsolute(@NotNull final String path) {
        return path.startsWith("/") || new File(path).isAbsolute();
    }

    public static boolean isRelative(@NotNull final String path) {
        return !path.startsWith("/") && !new File(path).isAbsolute();
    }

    @NotNull
    public static String relativeToAbsolute(@NotNull final String reference, @NotNull final String relative) {
        final String normalizedReference = reference.replace('\\', '/');
        final String normalizedRelative = relative.replace('\\', '/');
        if (isAbsolute(normalizedRelative)) {
            return normalizedRelative;
        }
        String work = normalizedReference.substring(0, normalizedReference.lastIndexOf('/') + 1) + normalizedRelative; // + 1 to include the "/"
        String work2;
        do {
            work2 = work;
            work = PATTERN_REDUNDANT.matcher(work2).replaceAll("");
        } while (!work2.equals(work));
        return work;
    }

    @NotNull
    public static String absoluteToRelative(@NotNull final String reference, @NotNull final String absolute) {
        final String normalizedReference = reference.replace('\\', '/');
        final String normalizedAbsolute = absolute.replace('\\', '/');
        if (isRelative(normalizedAbsolute)) {
            return normalizedAbsolute;
        }
        //String reference2 =
        // First: Strip equal path parts
        final int difference = findDifference(normalizedReference, normalizedAbsolute);
        final StringBuilder relative = new StringBuilder(normalizedAbsolute.substring(difference));
        final CharSequence referencePath = normalizedReference.substring(difference);
        for (int i = 0, l = findOccurrences(referencePath, '/'); i < l; i++) {
            relative.insert(0, "../");
        }
        return relative.toString();
    }

    private static int findDifference(@NotNull final CharSequence s1, @NotNull final CharSequence s2) {
        int s1slash = -1;
        int s2slash = -1;
        char c1 = (char) 0; // initialize for equality for first loop cycle
        char c2 = (char) 0;
        for (int index = 0, l1 = s1.length(), l2 = s2.length(); index < l1 && index < l2 && c1 == c2; index++) {
            c1 = s1.charAt(index);
            c2 = s2.charAt(index);
            if (c1 == '/') {
                s1slash = index;
            }
            if (c2 == '/') {
                s2slash = index;
            }
        }
        return Math.min(s1slash, s2slash) + 1;
    }

    private static int findOccurrences(@NotNull final CharSequence s, final char c) {
        int occurrences = 0;
        for (int i = 0, l = s.length(); i < l; i++) {
            if (s.charAt(i) == c) {
                occurrences++;
            }
        }
        return occurrences;
    }

    @NotNull
    public static String path(@NotNull final CharSequence str) {
        String path = StringUtils.PATTERN_BACKSLASH.matcher(str).replaceAll("/");
        path = path.endsWith("/") ? path.substring(0, path.length() - 1) : path;
        path = path.startsWith("file:") ? path.substring("file:".length()) : path;
        path = PATTERN_SLASHES.matcher(path).replaceAll("/");
        return path;
    }

    @NotNull
    public static String getAbsolutePath(@NotNull final CharSequence path) {
        return relativeToAbsolute(System.getProperty("user.dir") + "/dummy", path(path));
    }

}