PathName.h

/* miktex/Util/PathName.h:
 
   Copyright (C) 1996-2021 Christian Schenk
 
   This file is part of the MiKTeX Util Library.
 
   The MiKTeX Util Library 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, or
   (at your option) any later version.
 
   The MiKTeX Util Library 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 the MiKTeX Util Library; if not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA. */
 
#pragma once
 
#if !defined(CF4C28E918A44B66B3B0BEF7E88AB721)
#define CF4C28E918A44B66B3B0BEF7E88AB721
 
#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,
};
 
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;
 
public:
  PathName(const PathName& other) = default;
 
public:
  PathName& operator=(const PathName& other) = default;
 
public:
  PathName(PathName&& other) noexcept = default;
 
public:
  PathName& operator=(PathName&& other) noexcept = default;
 
public:
  virtual ~PathName() noexcept = default;
 
public:
  explicit PathName(const char* path) :
    Base(path)
  {
  }
 
public:
  explicit PathName(const wchar_t* path) :
    Base(path)
  {
  }
 
public:
  explicit PathName(const std::string& path) :
    Base(path)
  {
  }
 
public:
  explicit PathName(const std::wstring& path) :
    Base(path)
  {
  }
 
public:
  PathName(size_t n) = delete;
 
public:
  PathName(const char* component1, const char* component2) :
    Base(component1)
  {
    if (component2 != nullptr)
    {
      AppendComponent(component2);
    }
  }
 
public:
  PathName(const PathName& component1, const PathName& component2) :
    PathName(component1.GetData(), component2.GetData())
  {
  }
 
public:
  PathName& operator=(const char* path)
  {
    Base::operator= (path);
    return *this;
  }
 
public:
  PathName& operator=(const wchar_t* path)
  {
    Base::operator= (path);
    return *this;
  }
 
public:
  PathName& operator=(const std::string& path)
  {
    Base::operator= (path);
    return *this;
  }
 
public:
  PathName& operator=(const std::wstring& path)
  {
    Base::operator= (path);
    return *this;
  }
 
public:
  MIKTEXUTILTHISAPI(std::size_t) GetHash() const;
 
public:
  static MIKTEXUTILCEEAPI(std::vector<std::string>) Split(const PathName& path);
 
private:
  static MIKTEXUTILCEEAPI(void) Split(const PathName& path, std::string& directoryName, std::string& fileNameWithoutExtension, std::string& extension);
 
public:
  PathName GetDirectoryName() const
  {
    std::string directoryName;
    std::string fileNameWithoutExtension;
    std::string extension;
    Split(*this, directoryName, fileNameWithoutExtension, extension);
    return PathName(directoryName);
  }
 
public:
  PathName GetFileName() const
  {
    std::string directoryName;
    std::string fileNameWithoutExtension;
    std::string extension;
    Split(*this, directoryName, fileNameWithoutExtension, extension);
    return PathName(fileNameWithoutExtension + extension);
  }
 
public:
  PathName GetFileNameWithoutExtension() const
  {
    std::string directoryName;
    std::string fileNameWithoutExtension;
    std::string extension;
    Split(*this, directoryName, fileNameWithoutExtension, extension);
    return PathName(fileNameWithoutExtension);
  }
 
public:
  PathName& RemoveFileSpec()
  {
    return CutOffLastComponent();
  }
 
public:
  PathName& RemoveDirectorySpec()
  {
    Base::Set(GetFileName());
    return *this;
  }
  
public:
  MIKTEXUTILTHISAPI(PathName&) SetToHomeDirectory();
  
public:
  MIKTEXUTILTHISAPI(PathName&) SetToLockDirectory();
 
public:
  MIKTEXUTILTHISAPI(PathName&) SetToCurrentDirectory();
 
public:
  MIKTEXUTILTHISAPI(PathName&) SetToTempDirectory();
 
public:
  MIKTEXUTILTHISAPI(PathName&) SetToTempFile();
 
public:
  MIKTEXUTILTHISAPI(PathName&) SetToTempFile(const PathName& directory);
 
public:
  MIKTEXUTILTHISAPI(PathName) GetMountPoint() const;
 
public:
  MIKTEXUTILTHISAPI(PathName&) Convert(ConvertPathNameOptions options);
 
public:
  PathName& ConvertToUnix()
  {
    return Convert({ ConvertPathNameOption::ToUnix });
  }
 
public:
  PathName ToUnix() const
  {
    PathName result = *this;
    result.Convert({ ConvertPathNameOption::ToUnix });
    return result;
  }
 
public:
  PathName& ConvertToDos()
  {
    return Convert({ ConvertPathNameOption::ToDos });
  }
 
public:
  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
 
public:
  std::wstring ToWideCharString() const
  {
    return MiKTeX::Util::StringUtil::UTF8ToWideChar(GetData());
  }
 
#if defined(MIKTEX_WINDOWS)
public:
  std::wstring ToNativeString() const
  {
    return ToExtendedLengthPathName().ToWideCharString();
  }
#else
public:
  std::string ToNativeString() const
  {
    return ToString();
  }
#endif
 
public:
  MIKTEXUTILTHISAPI(std::string) ToDisplayString(DisplayPathNameOptions options = {}) const;
 
public:
  PathName& TransformForComparison()
  {
#if defined(MIKTEX_WINDOWS)
    return Convert({ ConvertPathNameOption::ToUnix, ConvertPathNameOption::MakeLower });
#else
    return *this;
#endif
  }
 
public:
  bool IsFullyQualified() const
  {
    return MiKTeX::Util::PathNameUtil::IsFullyQualifiedPath(ToString());
  }
 
public:
  bool IsAbsolute() const
  {
    return MiKTeX::Util::PathNameUtil::IsAbsolutePath(ToString());
  }
 
public:
  bool IsComparable() const
  {
#if defined(MIKTEX_WINDOWS)
    for (const char* lpsz = GetData(); *lpsz != 0; ++lpsz)
    {
      if (*lpsz == MiKTeX::Util::PathNameUtil::DosDirectoryDelimiter || (*lpsz >= 'A' && *lpsz <= 'Z'))
      {
        return false;
      }
    }
    return true;
#else
    return true;
#endif
  }
 
public:
  PathName& Canonicalize()
  {
    return Convert({ ConvertPathNameOption::Canonicalize });
  }
 
public:
  PathName& MakeFullyQualified()
  {
    return Convert({ ConvertPathNameOption::MakeFullyQualified });
  }
 
public:
  bool HasExtension() const
  {
    return !GetExtension().empty();
  }
 
public:
  bool HasExtension(const char* extension) const
  {
    std::string currentExtension = GetExtension();
    if (currentExtension.empty())
    {
      return false;
    }
    if (extension[0] == '.')
    {
      extension += 1;
    }
    return PathName::Compare(currentExtension.substr(1), extension) == 0;
  }
 
public:
  MIKTEXUTILTHISAPI(std::string) GetExtension() const;
 
public:
  MIKTEXUTILTHISAPI(PathName&) SetExtension(const char* extension, bool override);
 
public:
  PathName& SetExtension(const char* extension)
  {
    return SetExtension(extension, true);
  }
 
public:
  PathName& SetExtension(const std::string& extension)
  {
    return SetExtension(extension.c_str(), true);
  }
 
public:
  PathName& AppendExtension(const char* extension)
  {
    if (!HasExtension(extension))
    {
      if (*extension != '.')
      {
        Base::Append('.');
      }
      Base::Append(extension);
    }
    return *this;
  }
 
public:
  PathName& AppendExtension(const std::string& extension)
  {
    return AppendExtension(extension.c_str());
  }
 
public:
  bool EndsWithDirectoryDelimiter() const
  {
    std::size_t l = GetLength();
    return l > 0 && (MiKTeX::Util::PathNameUtil::IsDirectoryDelimiter(Base::operator[](l - 1)));
  }
 
public:
  PathName& Append(const char* lpsz, bool appendDirectoryDelimiter)
  {
    if (appendDirectoryDelimiter && !Empty() && !MiKTeX::Util::PathNameUtil::IsDirectoryDelimiter(lpsz[0]))
    {
      AppendDirectoryDelimiter();
    }
    Base::Append(lpsz);
    return *this;
  }
 
public:
  PathName& Append(const std::string& str, bool appendDirectoryDelimiter)
  {
    return Append(str.c_str(), appendDirectoryDelimiter);
  }
 
public:
  PathName& AppendComponent(const char* component)
  {
    return Append(component, true);
  }
 
public:
  PathName& operator/=(const char* component)
  {
    return AppendComponent(component);
  }
 
public:
  PathName& operator/=(const PathName& component)
  {
    return AppendComponent(component.GetData());
  }
 
public:
  PathName& operator/=(const std::string& component)
  {
    return AppendComponent(component.c_str());
  }
 
public:
  MIKTEXUTILTHISAPI(PathName&) CutOffLastComponent(bool allowSelfCutting);
 
public:
  PathName& CutOffLastComponent()
  {
    return CutOffLastComponent(false);
  }
 
public:
  MIKTEXUTILTHISAPI(PathName&) AppendDirectoryDelimiter();
 
#if defined(MIKTEX_WINDOWS)
public:
  MIKTEXUTILTHISAPI(PathName&) AppendAltDirectoryDelimiter();
#endif
 
public:
  bool IsExplicitlyRelative() const
  {
    return MiKTeX::Util::PathNameUtil::IsExplicitlyRelative(ToString());
  }
 
public:
  static MIKTEXUTILCEEAPI(int) Compare(const char* lpszPath1, const char* lpszPath2, std::size_t count);
 
public:
  static int Compare(const PathName& path1, const PathName& path2, std::size_t count)
  {
    return Compare(path1.GetData(), path2.GetData(), count);
  }
 
public:
  static MIKTEXUTILCEEAPI(int) Compare(const char* lpszPath1, const char* lpszPath2);
 
public:
  static int Compare(const PathName& path1, const PathName& path2)
  {
    return Compare(path1.GetData(), path2.GetData());
  }
 
public:
  static int Compare(const std::string& path1, const std::string& path2)
  {
    return Compare(path1.c_str(), path2.c_str());
  }
  
public:
  static bool Equals(const PathName& path1, const PathName& path2)
  {
    return Compare(path1, path2) == 0;
  }
 
public:
  static MIKTEXUTILCEEAPI(bool) Match(const char* lpszPattern, const char* lpszPath);
 
public:
  static bool Match(const char* lpszPattern, const PathName& path)
  {
    return Match(lpszPattern, path.GetData());
  }
};
 
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::Compare(lhs, rhs) == 0;
}
 
inline bool operator!=(const PathName& lhs, const PathName& rhs)
{
  return PathName::Compare(lhs, rhs) != 0;
}
 
inline PathName operator/(const PathName& lhs, const PathName& 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();
    }
  };
}
 
#endif