path.h

Go to the documentation of this file.

/*
 Copyright (C) 2001-2006, William Joseph.
 All Rights Reserved.

 This file is part of GtkRadiant.

 GtkRadiant 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.

 GtkRadiant 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 GtkRadiant; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined (INCLUDED_OS_PATH_H)
#define INCLUDED_OS_PATH_H

#include <string>

namespace os
{
    inline std::string standardPath (const std::string& inPath)
    {
        std::string newStr = inPath;
        std::string::size_type pos = newStr.find("\\");

        while (std::string::npos != pos) {
            newStr.replace(pos, 1, "/");
            pos = newStr.find("\\");
        }

        return newStr;
    }

    inline std::string getExtension (const std::string& path)
    {
        return path.substr(path.rfind(".") + 1);
    }

    inline std::string getFilenameFromPath (const std::string& path)
    {
        return path.substr(path.rfind("/") + 1);
    }

    inline std::string stripFilename (const std::string& filename)
    {
        return filename.substr(0, filename.rfind("/"));
    }

    inline std::string stripExtension (const std::string& filename)
    {
        std::string::size_type pos = filename.rfind(".");
        return filename.substr(0, pos);
    }
}

#include "string/string.h"

#include <glib.h>
#include <glib/gstdio.h>

#if defined(WIN32)
# define OS_CASE_INSENSITIVE
# ifndef PATH_MAX
#  define PATH_MAX 260
# endif
#endif

inline bool path_is_directory (const std::string& path)
{
    std::size_t length = path.length();
    if (length > 0)
        return path[length - 1] == '/';
    return false;
}

inline const char* path_get_filename_start (const char* path)
{
    // not strictly necessary,since paths should not contain '\'
    // mixed paths on windows containing both '/' and '\', use last of both for this
    const char* last_forward_slash = strrchr(path, '/');
    const char* last_backward_slash = strrchr(path, '\\');
    if (last_forward_slash > last_backward_slash) {
        return last_forward_slash + 1;
    } else if (last_forward_slash < last_backward_slash) {
        return last_backward_slash + 1;
    }

    return path;
}

inline bool path_less (const char* path, const char* other)
{
#if defined(OS_CASE_INSENSITIVE)
    return string_less_nocase(path, other);
#else
    return string_less(path, other);
#endif
}

inline int path_compare (const char* path, const char* other)
{
#if defined(OS_CASE_INSENSITIVE)
    return string_compare_nocase(path, other);
#else
    return string_compare(path, other);
#endif
}

inline bool path_equal (const std::string& path, const std::string& other)
{
#if defined(OS_CASE_INSENSITIVE)
    return string_equal_nocase(path, other);
#else
    return string_equal(path, other);
#endif
}

inline bool path_equal_n (const char* path, const char* other, std::size_t n)
{
#if defined(OS_CASE_INSENSITIVE)
    return string_equal_nocase_n(path, other, n);
#else
    return string_equal_n(path, other, n);
#endif
}

inline const char* path_get_filename_base_end (const char* path)
{
    const char* last_period = strrchr(path_get_filename_start(path), '.');
    return (last_period != 0) ? last_period : path + string_length(path);
}

inline std::size_t path_get_filename_base_length (const char* path)
{
    return path_get_filename_base_end(path) - path;
}

inline const char* path_make_relative (const char* path, const char* base)
{
    const std::size_t length = string_length(base);
    if (path_equal_n(path, base, length)) {
        return path + length;
    }
    return path;
}

inline bool extension_equal (const std::string& extension, const std::string& other)
{
    return path_equal(extension, other);
}

template<typename Functor>
class MatchFileExtension
{
        const char* m_extension;
        const Functor& m_functor;
    public:
        MatchFileExtension (const char* extension, const Functor& functor) :
            m_extension(extension), m_functor(functor)
        {
        }
        void operator() (const char* name) const
        {
            const std::string extension = os::getExtension(name);
            if (extension_equal(extension.c_str(), m_extension)) {
                m_functor(name);
            }
        }
};

class DirectoryCleaned
{
    public:
        const char* m_path;
        DirectoryCleaned (const char* path) :
            m_path(path)
        {
        }
};

template<typename TextOutputStreamType>
TextOutputStreamType& ostream_write (TextOutputStreamType& ostream, const DirectoryCleaned& path)
{
    const char* i = path.m_path;
    for (; *i != '\0'; ++i) {
        if (*i == '\\') {
            ostream << '/';
        } else {
            ostream << *i;
        }
    }
    const char c = *(i - 1);
    if (c != '/' && c != '\\') {
        ostream << '/';
    }
    return ostream;
}

#endif