Google Git
Sign in
apache / myfaces / 3ef155ee4b2999fcb8fd535a062dd566de264bea / . / impl / src / main / java / org / apache / myfaces / util / lang / FilenameUtils.java
blob: ea5236939f6b105a0110b427079da25f40698069 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.myfaces.util.lang;
import java.io.File;
/**
* General filename and filepath manipulation utilities.
* <p>
* When dealing with filenames you can hit problems when moving from a Windows
* based development machine to a Unix based production machine.
* This class aims to help avoid those problems.
* <p>
* <b>NOTE</b>: You may be able to avoid using this class entirely simply by
* using JDK {@link java.io.File File} objects and the two argument constructor
* {@link java.io.File#File(java.io.File, java.lang.String) File(File,String)}.
* <p>
* Most methods on this class are designed to work the same on both Unix and Windows.
* Those that don't include 'System', 'Unix' or 'Windows' in their name.
* <p>
* Most methods recognise both separators (forward and back), and both
* sets of prefixes. See the javadoc of each method for details.
* <p>
* This class defines six components within a filename
* (example C:\dev\project\file.txt):
* <ul>
* <li>the prefix - C:\</li>
* <li>the path - dev\project\</li>
* <li>the full path - C:\dev\project\</li>
* <li>the name - file.txt</li>
* <li>the base name - file</li>
* <li>the extension - txt</li>
* </ul>
* Note that this class works best if directory filenames end with a separator.
* If you omit the last separator, it is impossible to determine if the filename
* corresponds to a file or a directory. As a result, we have chosen to say
* it corresponds to a file.
* <p>
* This class only supports Unix and Windows style names.
* Prefixes are matched as follows:
* <pre>
* Windows:
* a\b\c.txt --&gt; "" --&gt; relative
* \a\b\c.txt --&gt; "\" --&gt; current drive absolute
* C:a\b\c.txt --&gt; "C:" --&gt; drive relative
* C:\a\b\c.txt --&gt; "C:\" --&gt; absolute
* \\server\a\b\c.txt --&gt; "\\server\" --&gt; UNC
*
* Unix:
* a/b/c.txt --&gt; "" --&gt; relative
* /a/b/c.txt --&gt; "/" --&gt; absolute
* ~/a/b/c.txt --&gt; "~/" --&gt; current user
* ~ --&gt; "~/" --&gt; current user (slash added)
* ~user/a/b/c.txt --&gt; "~user/" --&gt; named user
* ~user --&gt; "~user/" --&gt; named user (slash added)
* </pre>
* Both prefix styles are matched always, irrespective of the machine that you are
* currently running on.
* <p>
* Origin of code: Excalibur, Alexandria, Tomcat, Commons-Utils.
*
* NOTE: Taken from Commons-IO package
*
* @version $Id$
* @since 1.1
*/
public class FilenameUtils
{
/**
* The extension separator character.
*
* @since 1.4
*/
public static final char EXTENSION_SEPARATOR = '.';
/**
* The extension separator String.
*
* @since 1.4
*/
public static final String EXTENSION_SEPARATOR_STR = Character.toString(EXTENSION_SEPARATOR);
/**
* The Unix separator character.
*/
private static final char UNIX_SEPARATOR = '/';
/**
* The Windows separator character.
*/
private static final char WINDOWS_SEPARATOR = '\\';
/**
* The system separator character.
*/
private static final char SYSTEM_SEPARATOR = File.separatorChar;
/**
* The separator character that is the opposite of the system separator.
*/
private static final char OTHER_SEPARATOR;
static
{
if (isSystemWindows())
{
OTHER_SEPARATOR = UNIX_SEPARATOR;
}
else
{
OTHER_SEPARATOR = WINDOWS_SEPARATOR;
}
}
/**
* Instances should NOT be constructed in standard programming.
*/
public FilenameUtils()
{
super();
}
//-----------------------------------------------------------------------
/**
* Determines if Windows file system is in use.
*
* @return true if the system is Windows
*/
static boolean isSystemWindows()
{
return SYSTEM_SEPARATOR == WINDOWS_SEPARATOR;
}
//-----------------------------------------------------------------------
/**
* Checks if the character is a separator.
*
* @param ch the character to check
* @return true if it is a separator character
*/
private static boolean isSeparator(final char ch)
{
return ch == UNIX_SEPARATOR || ch == WINDOWS_SEPARATOR;
}
//-----------------------------------------------------------------------
/**
* Normalizes a path, removing double and single dot path steps.
* <p>
* This method normalizes a path to a standard format.
* The input may contain separators in either Unix or Windows format.
* The output will contain separators in the format of the system.
* <p>
* A trailing slash will be retained.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
* <p>
* The output will be the same on both Unix and Windows except
* for the separator character.
* <pre>
* /foo// --&gt; /foo/
* /foo/./ --&gt; /foo/
* /foo/../bar --&gt; /bar
* /foo/../bar/ --&gt; /bar/
* /foo/../bar/../baz --&gt; /baz
* //foo//./bar --&gt; /foo/bar
* /../ --&gt; null
* ../foo --&gt; null
* foo/bar/.. --&gt; foo/
* foo/../../bar --&gt; null
* foo/../bar --&gt; bar
* //server/foo/../bar --&gt; //server/bar
* //server/../bar --&gt; null
* C:\foo\..\bar --&gt; C:\bar
* C:\..\bar --&gt; null
* ~/foo/../bar/ --&gt; ~/bar/
* ~/../bar --&gt; null
* </pre>
* (Note the file separator returned will be correct for Windows/Unix)
*
* @param filename the filename to normalize, null returns null
* @return the normalized filename, or null if invalid
*/
public static String normalize(final String filename)
{
return doNormalize(filename, SYSTEM_SEPARATOR, true);
}
/**
* Normalizes a path, removing double and single dot path steps.
* <p>
* This method normalizes a path to a standard format.
* The input may contain separators in either Unix or Windows format.
* The output will contain separators in the format specified.
* <p>
* A trailing slash will be retained.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
* <p>
* The output will be the same on both Unix and Windows except
* for the separator character.
* <pre>
* /foo// --&gt; /foo/
* /foo/./ --&gt; /foo/
* /foo/../bar --&gt; /bar
* /foo/../bar/ --&gt; /bar/
* /foo/../bar/../baz --&gt; /baz
* //foo//./bar --&gt; /foo/bar
* /../ --&gt; null
* ../foo --&gt; null
* foo/bar/.. --&gt; foo/
* foo/../../bar --&gt; null
* foo/../bar --&gt; bar
* //server/foo/../bar --&gt; //server/bar
* //server/../bar --&gt; null
* C:\foo\..\bar --&gt; C:\bar
* C:\..\bar --&gt; null
* ~/foo/../bar/ --&gt; ~/bar/
* ~/../bar --&gt; null
* </pre>
* The output will be the same on both Unix and Windows including
* the separator character.
*
* @param filename the filename to normalize, null returns null
* @param unixSeparator {@code true} if a unix separator should
* be used or {@code false} if a windows separator should be used.
* @return the normalized filename, or null if invalid
* @since 2.0
*/
public static String normalize(final String filename, final boolean unixSeparator)
{
final char separator = unixSeparator ? UNIX_SEPARATOR : WINDOWS_SEPARATOR;
return doNormalize(filename, separator, true);
}
//-----------------------------------------------------------------------
/**
* Normalizes a path, removing double and single dot path steps,
* and removing any final directory separator.
* <p>
* This method normalizes a path to a standard format.
* The input may contain separators in either Unix or Windows format.
* The output will contain separators in the format of the system.
* <p>
* A trailing slash will be removed.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
* <p>
* The output will be the same on both Unix and Windows except
* for the separator character.
* <pre>
* /foo// --&gt; /foo
* /foo/./ --&gt; /foo
* /foo/../bar --&gt; /bar
* /foo/../bar/ --&gt; /bar
* /foo/../bar/../baz --&gt; /baz
* //foo//./bar --&gt; /foo/bar
* /../ --&gt; null
* ../foo --&gt; null
* foo/bar/.. --&gt; foo
* foo/../../bar --&gt; null
* foo/../bar --&gt; bar
* //server/foo/../bar --&gt; //server/bar
* //server/../bar --&gt; null
* C:\foo\..\bar --&gt; C:\bar
* C:\..\bar --&gt; null
* ~/foo/../bar/ --&gt; ~/bar
* ~/../bar --&gt; null
* </pre>
* (Note the file separator returned will be correct for Windows/Unix)
*
* @param filename the filename to normalize, null returns null
* @return the normalized filename, or null if invalid
*/
public static String normalizeNoEndSeparator(final String filename)
{
return doNormalize(filename, SYSTEM_SEPARATOR, false);
}
/**
* Normalizes a path, removing double and single dot path steps,
* and removing any final directory separator.
* <p>
* This method normalizes a path to a standard format.
* The input may contain separators in either Unix or Windows format.
* The output will contain separators in the format specified.
* <p>
* A trailing slash will be removed.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
* <p>
* The output will be the same on both Unix and Windows including
* the separator character.
* <pre>
* /foo// --&gt; /foo
* /foo/./ --&gt; /foo
* /foo/../bar --&gt; /bar
* /foo/../bar/ --&gt; /bar
* /foo/../bar/../baz --&gt; /baz
* //foo//./bar --&gt; /foo/bar
* /../ --&gt; null
* ../foo --&gt; null
* foo/bar/.. --&gt; foo
* foo/../../bar --&gt; null
* foo/../bar --&gt; bar
* //server/foo/../bar --&gt; //server/bar
* //server/../bar --&gt; null
* C:\foo\..\bar --&gt; C:\bar
* C:\..\bar --&gt; null
* ~/foo/../bar/ --&gt; ~/bar
* ~/../bar --&gt; null
* </pre>
*
* @param filename the filename to normalize, null returns null
* @param unixSeparator {@code true} if a unix separator should
* be used or {@code false} if a windows separtor should be used.
* @return the normalized filename, or null if invalid
* @since 2.0
*/
public static String normalizeNoEndSeparator(final String filename, final boolean unixSeparator)
{
final char separator = unixSeparator ? UNIX_SEPARATOR : WINDOWS_SEPARATOR;
return doNormalize(filename, separator, false);
}
/**
* Internal method to perform the normalization.
*
* @param filename the filename
* @param separator The separator character to use
* @param keepSeparator true to keep the final separator
* @return the normalized filename
*/
private static String doNormalize(final String filename, final char separator, final boolean keepSeparator)
{
if (filename == null)
{
return null;
}
int size = filename.length();
if (size == 0)
{
return filename;
}
final int prefix = getPrefixLength(filename);
if (prefix < 0)
{
return null;
}
final char[] array = new char[size + 2]; // +1 for possible extra slash, +2 for arraycopy
filename.getChars(0, filename.length(), array, 0);
// fix separators throughout
final char otherSeparator = separator == SYSTEM_SEPARATOR ? OTHER_SEPARATOR : SYSTEM_SEPARATOR;
for (int i = 0; i < array.length; i++)
{
if (array[i] == otherSeparator)
{
array[i] = separator;
}
}
// add extra separator on the end to simplify code below
boolean lastIsDirectory = true;
if (array[size - 1] != separator)
{
array[size++] = separator;
lastIsDirectory = false;
}
// adjoining slashes
for (int i = prefix + 1; i < size; i++)
{
if (array[i] == separator && array[i - 1] == separator)
{
System.arraycopy(array, i, array, i - 1, size - i);
size--;
i--;
}
}
// dot slash
for (int i = prefix + 1; i < size; i++)
{
if (array[i] == separator && array[i - 1] == '.'
&& (i == prefix + 1 || array[i - 2] == separator))
{
if (i == size - 1)
{
lastIsDirectory = true;
}
System.arraycopy(array, i + 1, array, i - 1, size - i);
size -= 2;
i--;
}
}
// double dot slash
outer:
for (int i = prefix + 2; i < size; i++)
{
if (array[i] == separator && array[i - 1] == '.' && array[i - 2] == '.'
&& (i == prefix + 2 || array[i - 3] == separator))
{
if (i == prefix + 2)
{
return null;
}
if (i == size - 1)
{
lastIsDirectory = true;
}
int j;
for (j = i - 4; j >= prefix; j--)
{
if (array[j] == separator)
{
// remove b/../ from a/b/../c
System.arraycopy(array, i + 1, array, j + 1, size - i);
size -= i - j;
i = j + 1;
continue outer;
}
}
// remove a/../ from a/../c
System.arraycopy(array, i + 1, array, prefix, size - i);
size -= i + 1 - prefix;
i = prefix + 1;
}
}
if (size <= 0)
{ // should never be less than 0
return "";
}
if (size <= prefix)
{ // should never be less than prefix
return new String(array, 0, size);
}
if (lastIsDirectory && keepSeparator)
{
return new String(array, 0, size); // keep trailing separator
}
return new String(array, 0, size - 1); // lose trailing separator
}
//-----------------------------------------------------------------------
/**
* Concatenates a filename to a base path using normal command line style rules.
* <p>
* The effect is equivalent to resultant directory after changing
* directory to the first argument, followed by changing directory to
* the second argument.
* <p>
* The first argument is the base path, the second is the path to concatenate.
* The returned path is always normalized via {@link #normalize(String)},
* thus <code>..</code> is handled.
* <p>
* If <code>pathToAdd</code> is absolute (has an absolute prefix), then
* it will be normalized and returned.
* Otherwise, the paths will be joined, normalized and returned.
* <p>
* The output will be the same on both Unix and Windows except
* for the separator character.
* <pre>
* /foo/ + bar --&gt; /foo/bar
* /foo + bar --&gt; /foo/bar
* /foo + /bar --&gt; /bar
* /foo + C:/bar --&gt; C:/bar
* /foo + C:bar --&gt; C:bar (*)
* /foo/a/ + ../bar --&gt; foo/bar
* /foo/ + ../../bar --&gt; null
* /foo/ + /bar --&gt; /bar
* /foo/.. + /bar --&gt; /bar
* /foo + bar/c.txt --&gt; /foo/bar/c.txt
* /foo/c.txt + bar --&gt; /foo/c.txt/bar (!)
* </pre>
* (*) Note that the Windows relative drive prefix is unreliable when
* used with this method.
* (!) Note that the first parameter must be a path. If it ends with a name, then
* the name will be built into the concatenated path. If this might be a problem,
* use {@link #getFullPath(String)} on the base path argument.
*
* @param basePath the base path to attach to, always treated as a path
* @param fullFilenameToAdd the filename (or path) to attach to the base
* @return the concatenated path, or null if invalid
*/
public static String concat(final String basePath, final String fullFilenameToAdd)
{
final int prefix = getPrefixLength(fullFilenameToAdd);
if (prefix < 0)
{
return null;
}
if (prefix > 0)
{
return normalize(fullFilenameToAdd);
}
if (basePath == null)
{
return null;
}
final int len = basePath.length();
if (len == 0)
{
return normalize(fullFilenameToAdd);
}
final char ch = basePath.charAt(len - 1);
if (isSeparator(ch))
{
return normalize(basePath + fullFilenameToAdd);
}
else
{
return normalize(basePath + '/' + fullFilenameToAdd);
}
}
//-----------------------------------------------------------------------
/**
* Converts all separators to the Unix separator of forward slash.
*
* @param path the path to be changed, null ignored
* @return the updated path
*/
public static String separatorsToUnix(final String path)
{
if (path == null || path.indexOf(WINDOWS_SEPARATOR) == -1)
{
return path;
}
return path.replace(WINDOWS_SEPARATOR, UNIX_SEPARATOR);
}
/**
* Converts all separators to the Windows separator of backslash.
*
* @param path the path to be changed, null ignored
* @return the updated path
*/
public static String separatorsToWindows(final String path)
{
if (path == null || path.indexOf(UNIX_SEPARATOR) == -1)
{
return path;
}
return path.replace(UNIX_SEPARATOR, WINDOWS_SEPARATOR);
}
/**
* Converts all separators to the system separator.
*
* @param path the path to be changed, null ignored
* @return the updated path
*/
public static String separatorsToSystem(final String path)
{
if (path == null)
{
return null;
}
if (isSystemWindows())
{
return separatorsToWindows(path);
}
else
{
return separatorsToUnix(path);
}
}
//-----------------------------------------------------------------------
/**
* Returns the length of the filename prefix, such as <code>C:/</code> or <code>~/</code>.
* <p>
* This method will handle a file in either Unix or Windows format.
* <p>
* The prefix length includes the first slash in the full filename
* if applicable. Thus, it is possible that the length returned is greater
* than the length of the input string.
* <pre>
* Windows:
* a\b\c.txt --&gt; "" --&gt; relative
* \a\b\c.txt --&gt; "\" --&gt; current drive absolute
* C:a\b\c.txt --&gt; "C:" --&gt; drive relative
* C:\a\b\c.txt --&gt; "C:\" --&gt; absolute
* \\server\a\b\c.txt --&gt; "\\server\" --&gt; UNC
* \\\a\b\c.txt --&gt; error, length = -1
*
* Unix:
* a/b/c.txt --&gt; "" --&gt; relative
* /a/b/c.txt --&gt; "/" --&gt; absolute
* ~/a/b/c.txt --&gt; "~/" --&gt; current user
* ~ --&gt; "~/" --&gt; current user (slash added)
* ~user/a/b/c.txt --&gt; "~user/" --&gt; named user
* ~user --&gt; "~user/" --&gt; named user (slash added)
* //server/a/b/c.txt --&gt; "//server/"
* ///a/b/c.txt --&gt; error, length = -1
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
* ie. both Unix and Windows prefixes are matched regardless.
*
* Note that a leading // (or \\) is used to indicate a UNC name on Windows.
* These must be followed by a server name, so double-slashes are not collapsed
* to a single slash at the start of the filename.
*
* @param filename the filename to find the prefix in, null returns -1
* @return the length of the prefix, -1 if invalid or null
*/
public static int getPrefixLength(final String filename)
{
if (filename == null)
{
return -1;
}
final int len = filename.length();
if (len == 0)
{
return 0;
}
char ch0 = filename.charAt(0);
if (ch0 == ':')
{
return -1;
}
if (len == 1)
{
if (ch0 == '~')
{
return 2; // return a length greater than the input
}
return isSeparator(ch0) ? 1 : 0;
}
else
{
if (ch0 == '~')
{
int posUnix = filename.indexOf(UNIX_SEPARATOR, 1);
int posWin = filename.indexOf(WINDOWS_SEPARATOR, 1);
if (posUnix == -1 && posWin == -1)
{
return len + 1; // return a length greater than the input
}
posUnix = posUnix == -1 ? posWin : posUnix;
posWin = posWin == -1 ? posUnix : posWin;
return Math.min(posUnix, posWin) + 1;
}
final char ch1 = filename.charAt(1);
if (ch1 == ':')
{
ch0 = Character.toUpperCase(ch0);
if (ch0 >= 'A' && ch0 <= 'Z')
{
if (len == 2 || isSeparator(filename.charAt(2)) == false)
{
return 2;
}
return 3;
}
return -1;
}
else if (isSeparator(ch0) && isSeparator(ch1))
{
int posUnix = filename.indexOf(UNIX_SEPARATOR, 2);
int posWin = filename.indexOf(WINDOWS_SEPARATOR, 2);
if (posUnix == -1 && posWin == -1 || posUnix == 2 || posWin == 2)
{
return -1;
}
posUnix = posUnix == -1 ? posWin : posUnix;
posWin = posWin == -1 ? posUnix : posWin;
return Math.min(posUnix, posWin) + 1;
}
else
{
return isSeparator(ch0) ? 1 : 0;
}
}
}
/**
* Returns the index of the last directory separator character.
* <p>
* This method will handle a file in either Unix or Windows format.
* The position of the last forward or backslash is returned.
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to find the last path separator in, null returns -1
* @return the index of the last separator character, or -1 if there
* is no such character
*/
public static int indexOfLastSeparator(final String filename)
{
if (filename == null)
{
return -1;
}
final int lastUnixPos = filename.lastIndexOf(UNIX_SEPARATOR);
final int lastWindowsPos = filename.lastIndexOf(WINDOWS_SEPARATOR);
return Math.max(lastUnixPos, lastWindowsPos);
}
/**
* Returns the index of the last extension separator character, which is a dot.
* <p>
* This method also checks that there is no directory separator after the last dot.
* To do this it uses {@link #indexOfLastSeparator(String)} which will
* handle a file in either Unix or Windows format.
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to find the last path separator in, null returns -1
* @return the index of the last separator character, or -1 if there
* is no such character
*/
public static int indexOfExtension(final String filename)
{
if (filename == null)
{
return -1;
}
final int extensionPos = filename.lastIndexOf(EXTENSION_SEPARATOR);
final int lastSeparator = indexOfLastSeparator(filename);
return lastSeparator > extensionPos ? -1 : extensionPos;
}
//-----------------------------------------------------------------------
/**
* Gets the prefix from a full filename, such as <code>C:/</code>
* or <code>~/</code>.
* <p>
* This method will handle a file in either Unix or Windows format.
* The prefix includes the first slash in the full filename where applicable.
* <pre>
* Windows:
* a\b\c.txt --&gt; "" --&gt; relative
* \a\b\c.txt --&gt; "\" --&gt; current drive absolute
* C:a\b\c.txt --&gt; "C:" --&gt; drive relative
* C:\a\b\c.txt --&gt; "C:\" --&gt; absolute
* \\server\a\b\c.txt --&gt; "\\server\" --&gt; UNC
*
* Unix:
* a/b/c.txt --&gt; "" --&gt; relative
* /a/b/c.txt --&gt; "/" --&gt; absolute
* ~/a/b/c.txt --&gt; "~/" --&gt; current user
* ~ --&gt; "~/" --&gt; current user (slash added)
* ~user/a/b/c.txt --&gt; "~user/" --&gt; named user
* ~user --&gt; "~user/" --&gt; named user (slash added)
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
* ie. both Unix and Windows prefixes are matched regardless.
*
* @param filename the filename to query, null returns null
* @return the prefix of the file, null if invalid
*/
public static String getPrefix(final String filename)
{
if (filename == null)
{
return null;
}
final int len = getPrefixLength(filename);
if (len < 0)
{
return null;
}
if (len > filename.length())
{
return filename + UNIX_SEPARATOR; // we know this only happens for unix
}
return filename.substring(0, len);
}
/**
* Gets the path from a full filename, which excludes the prefix.
* <p>
* This method will handle a file in either Unix or Windows format.
* The method is entirely text based, and returns the text before and
* including the last forward or backslash.
* <pre>
* C:\a\b\c.txt --&gt; a\b\
* ~/a/b/c.txt --&gt; a/b/
* a.txt --&gt; ""
* a/b/c --&gt; a/b/
* a/b/c/ --&gt; a/b/c/
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
* <p>
* This method drops the prefix from the result.
* See {@link #getFullPath(String)} for the method that retains the prefix.
*
* @param filename the filename to query, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
*/
public static String getPath(final String filename)
{
return doGetPath(filename, 1);
}
/**
* Gets the path from a full filename, which excludes the prefix, and
* also excluding the final directory separator.
* <p>
* This method will handle a file in either Unix or Windows format.
* The method is entirely text based, and returns the text before the
* last forward or backslash.
* <pre>
* C:\a\b\c.txt --&gt; a\b
* ~/a/b/c.txt --&gt; a/b
* a.txt --&gt; ""
* a/b/c --&gt; a/b
* a/b/c/ --&gt; a/b/c
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
* <p>
* This method drops the prefix from the result.
* See {@link #getFullPathNoEndSeparator(String)} for the method that retains the prefix.
*
* @param filename the filename to query, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
*/
public static String getPathNoEndSeparator(final String filename)
{
return doGetPath(filename, 0);
}
/**
* Does the work of getting the path.
*
* @param filename the filename
* @param separatorAdd 0 to omit the end separator, 1 to return it
* @return the path
*/
private static String doGetPath(final String filename, final int separatorAdd)
{
if (filename == null)
{
return null;
}
final int prefix = getPrefixLength(filename);
if (prefix < 0)
{
return null;
}
final int index = indexOfLastSeparator(filename);
final int endIndex = index + separatorAdd;
if (prefix >= filename.length() || index < 0 || prefix >= endIndex)
{
return "";
}
return filename.substring(prefix, endIndex);
}
/**
* Gets the full path from a full filename, which is the prefix + path.
* <p>
* This method will handle a file in either Unix or Windows format.
* The method is entirely text based, and returns the text before and
* including the last forward or backslash.
* <pre>
* C:\a\b\c.txt --&gt; C:\a\b\
* ~/a/b/c.txt --&gt; ~/a/b/
* a.txt --&gt; ""
* a/b/c --&gt; a/b/
* a/b/c/ --&gt; a/b/c/
* C: --&gt; C:
* C:\ --&gt; C:\
* ~ --&gt; ~/
* ~/ --&gt; ~/
* ~user --&gt; ~user/
* ~user/ --&gt; ~user/
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to query, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
*/
public static String getFullPath(final String filename)
{
return doGetFullPath(filename, true);
}
/**
* Gets the full path from a full filename, which is the prefix + path,
* and also excluding the final directory separator.
* <p>
* This method will handle a file in either Unix or Windows format.
* The method is entirely text based, and returns the text before the
* last forward or backslash.
* <pre>
* C:\a\b\c.txt --&gt; C:\a\b
* ~/a/b/c.txt --&gt; ~/a/b
* a.txt --&gt; ""
* a/b/c --&gt; a/b
* a/b/c/ --&gt; a/b/c
* C: --&gt; C:
* C:\ --&gt; C:\
* ~ --&gt; ~
* ~/ --&gt; ~
* ~user --&gt; ~user
* ~user/ --&gt; ~user
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to query, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
*/
public static String getFullPathNoEndSeparator(final String filename)
{
return doGetFullPath(filename, false);
}
/**
* Does the work of getting the path.
*
* @param filename the filename
* @param includeSeparator true to include the end separator
* @return the path
*/
private static String doGetFullPath(final String filename, final boolean includeSeparator)
{
if (filename == null)
{
return null;
}
final int prefix = getPrefixLength(filename);
if (prefix < 0)
{
return null;
}
if (prefix >= filename.length())
{
if (includeSeparator)
{
return getPrefix(filename); // add end slash if necessary
}
else
{
return filename;
}
}
final int index = indexOfLastSeparator(filename);
if (index < 0)
{
return filename.substring(0, prefix);
}
int end = index + (includeSeparator ? 1 : 0);
if (end == 0)
{
end++;
}
return filename.substring(0, end);
}
/**
* Gets the name minus the path from a full filename.
* <p>
* This method will handle a file in either Unix or Windows format.
* The text after the last forward or backslash is returned.
* <pre>
* a/b/c.txt --&gt; c.txt
* a.txt --&gt; a.txt
* a/b/c --&gt; c
* a/b/c/ --&gt; ""
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to query, null returns null
* @return the name of the file without the path, or an empty string if none exists
*/
public static String getName(final String filename)
{
if (filename == null)
{
return null;
}
final int index = indexOfLastSeparator(filename);
return filename.substring(index + 1);
}
/**
* Gets the base name, minus the full path and extension, from a full filename.
* <p>
* This method will handle a file in either Unix or Windows format.
* The text after the last forward or backslash and before the last dot is returned.
* <pre>
* a/b/c.txt --&gt; c
* a.txt --&gt; a
* a/b/c --&gt; c
* a/b/c/ --&gt; ""
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to query, null returns null
* @return the name of the file without the path, or an empty string if none exists
*/
public static String getBaseName(final String filename)
{
return removeExtension(getName(filename));
}
/**
* Gets the extension of a filename.
* <p>
* This method returns the textual part of the filename after the last dot.
* There must be no directory separator after the dot.
* <pre>
* foo.txt --&gt; "txt"
* a/b/c.jpg --&gt; "jpg"
* a/b.txt/c --&gt; ""
* a/b/c --&gt; ""
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to retrieve the extension of.
* @return the extension of the file or an empty string if none exists or {@code null}
* if the filename is {@code null}.
*/
public static String getExtension(final String filename)
{
if (filename == null)
{
return null;
}
final int index = indexOfExtension(filename);
if (index == -1)
{
return "";
}
else
{
return filename.substring(index + 1);
}
}
//-----------------------------------------------------------------------
/**
* Removes the extension from a filename.
* <p>
* This method returns the textual part of the filename before the last dot.
* There must be no directory separator after the dot.
* <pre>
* foo.txt --&gt; foo
* a\b\c.jpg --&gt; a\b\c
* a\b\c --&gt; a\b\c
* a.b\c --&gt; a.b\c
* </pre>
* <p>
* The output will be the same irrespective of the machine that the code is running on.
*
* @param filename the filename to query, null returns null
* @return the filename minus the extension
*/
public static String removeExtension(final String filename)
{
if (filename == null)
{
return null;
}
final int index = indexOfExtension(filename);
if (index == -1)
{
return filename;
}
else
{
return filename.substring(0, index);
}
}
}