예제 #1
0
//==============================================================================
bool File::isAbsolutePath (StringRef path)
{
    auto firstChar = *(path.text);

    return firstChar == getSeparatorChar()
           #if JUCE_WINDOWS
            || (firstChar != 0 && path.text[1] == ':');
           #else
            || firstChar == '~';
예제 #2
0
String File::getFileNameWithoutExtension() const
{
    auto lastSlash = fullPath.lastIndexOfChar (getSeparatorChar()) + 1;
    auto lastDot   = fullPath.lastIndexOfChar ('.');

    if (lastDot > lastSlash)
        return fullPath.substring (lastSlash, lastDot);

    return fullPath.substring (lastSlash);
}
예제 #3
0
//==============================================================================
String File::getPathUpToLastSlash() const
{
    auto lastSlash = fullPath.lastIndexOfChar (getSeparatorChar());

    if (lastSlash > 0)
        return fullPath.substring (0, lastSlash);

    if (lastSlash == 0)
        return getSeparatorString();

    return fullPath;
}
예제 #4
0
//==============================================================================
String FileSystem::normalize(const String& path) const
{
	if(path.empty())
	{
		return path;
	}
	else
	{
		String ret = path;

		//
		// Replace separator characters with the appropriate type
		//
		const CharType sep = getSeparatorChar();
		const CharType badSep = (sep == '/') ? '\\' : '/';
		std::replace(ret.begin(), ret.end(), badSep, sep);

		// Replace strings of separators with a single separator
		// starting at position 0 for UNIX and 1 for Windows!
		size_t pos = (sep == '\\') ? 1 : 0;
		const CharType doubleSep[] = {sep, sep, 0};
		while(pos != String::npos)
		{
			pos = ret.find(doubleSep, pos);
			if(pos != String::npos)
			{
				ret.erase(pos, 1);
			}
		}

		//
		// Remove terminating separator if any
		//
		if(sep == ret[ret.length()-1] && getPrefixLength(ret) < ret.length())
		{
			ret = ret.erase(ret.length()-1);
		}

		return ret;
	}
}
예제 #5
0
// If the child is absolute, then we do not resolve the child against
// the parent.  This seems to make the most logical sense, even though
// that is not the apparent behaviour of the JDK.
//
// If the parent directory is empty, this is not treated as the current
// working directory, but simply as the empty string.
// This allows this class to be used in URL resolution where the current
// directory has no meaning.
//==============================================================================
String FileSystem::resolve(const String& parent, const String& child) const
{
	String normalizedChild = normalize(child);
	if(isAbsolute(normalizedChild))
	{
		return normalizedChild;
	}
	else
	{
		size_t prefixLen = getPrefixLength(normalizedChild);
		String normalizedParent = normalize(parent);
		const CharType lastChar = normalizedParent[normalizedParent.length()-1];
		if(lastChar == getSeparatorChar())
		{
			return normalizedParent + normalizedChild.substr(prefixLen);
		}
		else
		{
			return normalizedParent + getSeparator() + normalizedChild.substr(prefixLen);
		}
	}
}
예제 #6
0
//==============================================================================
String File::getFileName() const
{
    return fullPath.substring (fullPath.lastIndexOfChar (getSeparatorChar()) + 1);
}
예제 #7
0
String File::addTrailingSeparator (const String& path)
{
    return path.endsWithChar (getSeparatorChar()) ? path
                                                  : path + getSeparatorChar();
}
예제 #8
0
String File::parseAbsolutePath (const String& p)
{
    if (p.isEmpty())
        return {};

#if JUCE_WINDOWS
    // Windows..
    auto path = removeEllipsis (p.replaceCharacter ('/', '\\'));

    if (path.startsWithChar (getSeparatorChar()))
    {
        if (path[1] != getSeparatorChar())
        {
            /*  When you supply a raw string to the File object constructor, it must be an absolute path.
                If you're trying to parse a string that may be either a relative path or an absolute path,
                you MUST provide a context against which the partial path can be evaluated - you can do
                this by simply using File::getChildFile() instead of the File constructor. E.g. saying
                "File::getCurrentWorkingDirectory().getChildFile (myUnknownPath)" would return an absolute
                path if that's what was supplied, or would evaluate a partial path relative to the CWD.
            */
            jassertfalse;

            path = File::getCurrentWorkingDirectory().getFullPathName().substring (0, 2) + path;
        }
    }
    else if (! path.containsChar (':'))
    {
        /*  When you supply a raw string to the File object constructor, it must be an absolute path.
            If you're trying to parse a string that may be either a relative path or an absolute path,
            you MUST provide a context against which the partial path can be evaluated - you can do
            this by simply using File::getChildFile() instead of the File constructor. E.g. saying
            "File::getCurrentWorkingDirectory().getChildFile (myUnknownPath)" would return an absolute
            path if that's what was supplied, or would evaluate a partial path relative to the CWD.
        */
        jassertfalse;

        return File::getCurrentWorkingDirectory().getChildFile (path).getFullPathName();
    }
#else
    // Mac or Linux..

    // Yes, I know it's legal for a unix pathname to contain a backslash, but this assertion is here
    // to catch anyone who's trying to run code that was written on Windows with hard-coded path names.
    // If that's why you've ended up here, use File::getChildFile() to build your paths instead.
    jassert ((! p.containsChar ('\\')) || (p.indexOfChar ('/') >= 0 && p.indexOfChar ('/') < p.indexOfChar ('\\')));

    auto path = removeEllipsis (p);

    if (path.startsWithChar ('~'))
    {
        if (path[1] == getSeparatorChar() || path[1] == 0)
        {
            // expand a name of the form "~/abc"
            path = File::getSpecialLocation (File::userHomeDirectory).getFullPathName()
                    + path.substring (1);
        }
        else
        {
            // expand a name of type "~dave/abc"
            auto userName = path.substring (1).upToFirstOccurrenceOf ("/", false, false);

            if (auto* pw = getpwnam (userName.toUTF8()))
                path = addTrailingSeparator (pw->pw_dir) + path.fromFirstOccurrenceOf ("/", false, false);
        }
    }
    else if (! path.startsWithChar (getSeparatorChar()))
    {
       #if JUCE_DEBUG || JUCE_LOG_ASSERTIONS
        if (! (path.startsWith ("./") || path.startsWith ("../")))
        {
            /*  When you supply a raw string to the File object constructor, it must be an absolute path.
                If you're trying to parse a string that may be either a relative path or an absolute path,
                you MUST provide a context against which the partial path can be evaluated - you can do
                this by simply using File::getChildFile() instead of the File constructor. E.g. saying
                "File::getCurrentWorkingDirectory().getChildFile (myUnknownPath)" would return an absolute
                path if that's what was supplied, or would evaluate a partial path relative to the CWD.
            */
            jassertfalse;

           #if JUCE_LOG_ASSERTIONS
            Logger::writeToLog ("Illegal absolute path: " + path);
           #endif
        }
       #endif

        return File::getCurrentWorkingDirectory().getChildFile (path).getFullPathName();
    }
#endif

    while (path.endsWithChar (getSeparatorChar()) && path != getSeparatorString()) // careful not to turn a single "/" into an empty string.
        path = path.dropLastCharacters (1);

    return path;
}
예제 #9
0
//==============================================================================
String FileSystem::getSeparator() const
{
	return String(1, getSeparatorChar());
}