PathName.h

Go to the documentation of this file.

 
#pragma once
 
#include <miktex/Util/config.h>
 
#include <ostream>
#include <string>
#include <vector>
 
#include <miktex/Util/CharBuffer>
#include <miktex/Util/PathNameUtil>
 
#include "OptionSet.h"
 
MIKTEX_UTIL_BEGIN_NAMESPACE;

enum class ConvertPathNameOption
{
    ToUnix,
    ToDos,
    MakeLower,
    MakeUpper,
#if defined(MIKTEX_WINDOWS)
    ToExtendedLengthPathName,
#endif
    MakeFullyQualified,
    Canonicalize,
    CleanUp,
};

typedef OptionSet<ConvertPathNameOption> ConvertPathNameOptions;
 
enum class DisplayPathNameOption
{
};
 
typedef OptionSet<DisplayPathNameOption> DisplayPathNameOptions;

class PathName :
    public MiKTeX::Util::CharBuffer<char, MIKTEX_UTIL_PATHNAME_SIZE>
{
 
protected:
 
    typedef CharBuffer<char, MIKTEX_UTIL_PATHNAME_SIZE> Base;
 
public:
 
    PathName() = default;
    PathName(const PathName& other) = default;
    PathName& operator=(const PathName& other) = default;
    PathName(PathName&& other) noexcept = default;
    PathName& operator=(PathName&& other) noexcept = default;
    virtual ~PathName() noexcept = default;

    explicit PathName(const char* path) :
        Base(path)
    {
    }

    explicit PathName(const wchar_t* path) :
        Base(path)
    {
    }

    explicit PathName(const std::string& path) :
        Base(path)
    {
    }

    explicit PathName(const std::wstring& path) :
        Base(path)
    {
    }
 
    PathName(size_t n) = delete;
 
    PathName& operator=(const char* path)
    {
        Base::operator=(path);
        return *this;
    }
 
    PathName& operator=(const wchar_t* path)
    {
        Base::operator=(path);
        return *this;
    }
 
    PathName& operator=(const std::string& path)
    {
        Base::operator=(path);
        return *this;
    }
 
    PathName& operator=(const std::wstring& path)
    {
        Base::operator=(path);
        return *this;
    }

    MIKTEXUTILTHISAPI(std::size_t) GetHash() const;
 
    static MIKTEXUTILCEEAPI(std::vector<std::string>) Split(const PathName& path);
 
 
    PathName GetDirectoryName() const
    {
        std::string directoryName;
        std::string fileNameWithoutExtension;
        std::string extension;
        Split(*this, directoryName, fileNameWithoutExtension, extension);
        return PathName(directoryName);
    }
 
    PathName GetFileName() const
    {
        std::string directoryName;
        std::string fileNameWithoutExtension;
        std::string extension;
        Split(*this, directoryName, fileNameWithoutExtension, extension);
        return PathName(fileNameWithoutExtension + extension);
    }
 
    PathName GetFileNameWithoutExtension() const
    {
        std::string directoryName;
        std::string fileNameWithoutExtension;
        std::string extension;
        Split(*this, directoryName, fileNameWithoutExtension, extension);
        return PathName(fileNameWithoutExtension);
    }

    PathName& RemoveFileSpec()
    {
        return CutOffLastComponent();
    }

    PathName& RemoveDirectorySpec()
    {
        Base::Set(GetFileName());
        return *this;
    }
 
    MIKTEXUTILTHISAPI(PathName&) SetToHomeDirectory();
 
    MIKTEXUTILTHISAPI(PathName&) SetToLockDirectory();

    MIKTEXUTILTHISAPI(PathName&) SetToCurrentDirectory();

    MIKTEXUTILTHISAPI(PathName&) SetToTempDirectory();

    MIKTEXUTILTHISAPI(PathName&) SetToTempFile();

    MIKTEXUTILTHISAPI(PathName&) SetToTempFile(const PathName& directory);

    MIKTEXUTILTHISAPI(PathName) GetMountPoint() const;
 
    MIKTEXUTILTHISAPI(PathName&) Convert(ConvertPathNameOptions options);

    PathName& Clean()
    {
        return Convert({ ConvertPathNameOption::CleanUp });
    }

    PathName& ConvertToUnix()
    {
        return Convert({ ConvertPathNameOption::ToUnix });
    }
 
    PathName ToUnix() const
    {
        PathName result = *this;
        result.Convert({ ConvertPathNameOption::ToUnix });
        return result;
    }

    PathName& ConvertToDos()
    {
        return Convert({ ConvertPathNameOption::ToDos });
    }
 
    PathName ToDos() const
    {
        PathName result = *this;
        result.Convert({ ConvertPathNameOption::ToDos });
        return result;
    }
 
#if defined(MIKTEX_WINDOWS)
    PathName ToExtendedLengthPathName() const
    {
        PathName result = *this;
        result.Convert({ ConvertPathNameOption::ToExtendedLengthPathName });
        return result;
    }
#endif
 
    std::wstring ToWideCharString() const
    {
        return MiKTeX::Util::StringUtil::UTF8ToWideChar(ToString());
    }
 
#if defined(MIKTEX_WINDOWS)
    std::wstring ToNativeString() const
    {
        return ToExtendedLengthPathName().ToWideCharString();
    }
#else
    std::string ToNativeString() const
    {
        return ToString();
    }
#endif
 
    MIKTEXUTILTHISAPI(std::string) ToDisplayString(DisplayPathNameOptions options = {}) const;

    PathName& TransformForComparison()
    {
#if defined(MIKTEX_WINDOWS)
        return Convert({ ConvertPathNameOption::ToUnix, ConvertPathNameOption::MakeLower });
#else
        return *this;
#endif
    }
 
    bool IsFullyQualified() const
    {
        return MiKTeX::Util::PathNameUtil::IsFullyQualifiedPath(ToString());
    }
 
    bool IsAbsolute() const
    {
        return MiKTeX::Util::PathNameUtil::IsAbsolutePath(ToString());
    }
 
    PathName& Canonicalize()
    {
        return Convert({ ConvertPathNameOption::Canonicalize });
    }

    PathName& MakeFullyQualified()
    {
        return Convert({ ConvertPathNameOption::MakeFullyQualified });
    }
 
    bool HasExtension() const
    {
        return !GetExtension().empty();
    }

    bool HasExtension(const std::string& extension_) const
    {
        if (extension_.empty())
        {
            return false;
        }
        std::string currentExtension = GetExtension();
        if (currentExtension.empty())
        {
            return false;
        }
        auto extension = extension_;
        if (extension[0] == '.')
        {
            extension.erase(0, 1);
        }
        if (currentExtension[0] == '.')
        {
            currentExtension.erase(0, 1);
        }
        return PathName::Equals(PathName(currentExtension), PathName(extension));
    }

    MIKTEXUTILTHISAPI(std::string) GetExtension() const;

    MIKTEXUTILTHISAPI(PathName&) SetExtension(const std::string& extension, bool override);

    PathName& SetExtension(const std::string& extension)
    {
        return SetExtension(extension, true);
    }
 
    PathName& AppendExtension(const std::string& extension)
    {
        if (!HasExtension(extension))
        {
            if (!extension.empty() && extension[0] != '.')
            {
                Base::Append('.');
            }
            Base::Append(extension);
        }
        return *this;
    }

    bool EndsWithDirectoryDelimiter() const
    {
        std::size_t l = GetLength();
        return l > 0 && (MiKTeX::Util::PathNameUtil::IsDirectoryDelimiter(Base::operator[](l - 1)));
    }

    PathName& Append(const std::string& s, bool appendDirectoryDelimiter)
    {
        if (appendDirectoryDelimiter && !Empty() && !s.empty() && !MiKTeX::Util::PathNameUtil::IsDirectoryDelimiter(s[0]))
        {
            AppendDirectoryDelimiter();
        }
        Base::Append(s);
        return *this;
    }

    PathName& AppendComponent(const std::string& component)
    {
        return Append(component, true);
    }

    PathName& operator/=(const std::string& component)
    {
        return AppendComponent(component);
    }

    MIKTEXUTILTHISAPI(PathName&) CutOffLastComponent(bool allowSelfCutting);

    PathName& CutOffLastComponent()
    {
        return CutOffLastComponent(false);
    }

    MIKTEXUTILTHISAPI(PathName&) AppendDirectoryDelimiter();
 
#if defined(MIKTEX_WINDOWS)
    MIKTEXUTILTHISAPI(PathName&) AppendAltDirectoryDelimiter();
#endif
 
    bool IsExplicitlyRelative() const
    {
        return MiKTeX::Util::PathNameUtil::IsExplicitlyRelative(ToString());
    }

    static MIKTEXUTILCEEAPI(int) ComparePrefixes(const PathName& path1, const PathName& path2, std::size_t count);

    static MIKTEXUTILCEEAPI(int) Compare(const PathName& path1, const PathName& path2);
 
    static bool Equals(const PathName& path1, const PathName& path2)
    {
        return Compare(path1, path2) == 0;
    }

    static MIKTEXUTILCEEAPI(bool) Match(const std::string& pattern, const PathName& path);
 
private:
 
    static MIKTEXUTILCEEAPI(void) Split(const PathName& path, std::string& directoryName, std::string& fileNameWithoutExtension, std::string& extension);
 
};
 
inline bool operator<(const PathName& lhs, const PathName& rhs)
{
    return PathName::Compare(lhs, rhs) < 0;
}

inline bool operator==(const PathName& lhs, const PathName& rhs)
{
    return PathName::Equals(lhs, rhs);
}

inline bool operator!=(const PathName& lhs, const PathName& rhs)
{
    return !PathName::Equals(lhs, rhs);
}
 
inline PathName operator/(const PathName& lhs, const std::string& rhs)
{
    PathName result = lhs;
    result /= rhs;
    return result;
}
 
inline std::ostream& operator<<(std::ostream& os, const PathName& path)
{
    return os << path.ToDisplayString();
}
 
MIKTEX_UTIL_END_NAMESPACE;
 
namespace std
{
    template<> struct hash<MiKTeX::Util::PathName>
    {
        std::size_t operator()(const MiKTeX::Util::PathName& path) const
        {
            return path.GetHash();
        }
    };
}