pathutil.cpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
//---------------------------------------------------------------------------
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#endif
 
#include <utf8cpp/utf8.h>
#if 0 && __has_include(<utf8cpp/cpp17.h>)  // don't needed here
  #include <utf8cpp/cpp17.h>
  #define LIBXCKS_UTF8CPP_HAS_STRING_VIEW
#endif
 
#include <algorithm>
#include <iterator>
#include <cstdio>
 
#include "pathutil.hpp"
#include "strutil.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
 
using namespace std::filesystem;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
//###########################################################################
// Directories functions
//###########################################################################
std::vector<std::filesystem::path> getDirectories(const std::filesystem::path& p)
{
  vector<path> paths;
  path pp = p.relative_path().parent_path();
  copy(pp.begin(), pp.end(), back_inserter(paths));
 
  return paths;
}
//---------------------------------------------------------------------------
 
 
ArrayString getDirectoriesAsArrayString(const std::filesystem::path& p)
{
  ArrayString paths;
  path pp = p.relative_path().parent_path();
  for (path d : pp)
    paths.emplace_back(from_u8string(d.u8string()));
 
  return paths;
}
//---------------------------------------------------------------------------
 
 
 
//###########################################################################
// Comparison functions
//###########################################################################
 
int compareFileName(const std::string& fn1, const std::string& fn2)
{
  int res;
  #if defined(_WIN32) || defined(_WIN64)
  wstring wfn1, wfn2;
  utf8::utf8to16(fn1.begin(), fn1.end(), back_inserter(wfn1));
  utf8::utf8to16(fn2.begin(), fn2.end(), back_inserter(wfn2));
 
  res = CompareStringEx(LOCALE_NAME_USER_DEFAULT, NORM_IGNORECASE, wfn1.c_str(), wfn1.size(), wfn2.c_str(), wfn2.size(), nullptr, nullptr, 0) - CSTR_EQUAL;
  //res = CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, wfn1.c_str(), -1, wfn2.c_str(), -1) - CSTR_EQUAL;
  #else
  res = fn1.compare(fn2);
  #endif  // _WIN32 || _WIN64
 
  return res;
}
//---------------------------------------------------------------------------
 
 
int compareFileName(const std::filesystem::path& p1, const std::filesystem::path& p2)
{
  int res;
 
  #if defined(_WIN32) || defined(_WIN64)
  wstring wfn1 = p1.filename().wstring();
  wstring wfn2 = p2.filename().wstring();
 
  res = CompareStringEx(LOCALE_NAME_USER_DEFAULT, NORM_IGNORECASE, wfn1.c_str(), wfn1.size(), wfn2.c_str(), wfn2.size(), nullptr, nullptr, 0) - CSTR_EQUAL;
  //res = CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, wfn1.c_str(), -1, wfn2.c_str(), -1) - CSTR_EQUAL;
  #else
  u32string fn1 = p1.filename().u32string();
  u32string fn2 = p2.filename().u32string();
  res = fn1.compare(fn2);
  #endif  // _WIN32 || _WIN64
 
  return res;
}
//---------------------------------------------------------------------------
 
 
 
//###########################################################################
// Construction functions
//###########################################################################
 
std::filesystem::path constructPath(const ArrayString& dirs, const std::string& filename)
{
  const char32_t sep = U'/';
  u32string p;
  for (const string& d : dirs)
  {
    if (!p.empty())
      p += sep;
    #if defined(_MSC_VER)
    utf8::utf8to32(d.c_str(), d.c_str() + d.size(), back_inserter(p));
    #else
    p += utf8::utf8to32(d);
    #endif
  }
  if (!filename.empty())
  {
    if (!p.empty())
      p += sep;
    #if defined(_MSC_VER)
    utf8::utf8to32(filename.c_str(), filename.c_str() + filename.size(), back_inserter(p));
    #else
    p += utf8::utf8to32(filename);
    #endif
  }
 
  return path(p).make_preferred();
}
//---------------------------------------------------------------------------
 
 
std::filesystem::path ensureEndsWithPathSeparator(const std::filesystem::path& p)
{
  u32string generic = p.generic_u32string();
  if (generic.back() == U'/')
    return path(p).make_preferred();
  else
  {
    generic.push_back(U'/');
    return path(generic).make_preferred();
  }
}
//---------------------------------------------------------------------------
 
 
 
//###########################################################################
// Check functions
//###########################################################################
 
bool isFileNameValid(const std::string& filename)
{
  if (filename.empty())
    return false;
 
  #if defined(__unix__) || defined(__unix) || defined(_WIN32) || defined(_WIN64)
  if ((filename == ".") || (filename == ".."))
    return false;
  #endif
 
  #if defined(__APPLE__) && !(defined(__unix__) || defined(__unix))
  char invalidChars[] = { '/', ':', '\0' };
  #elif defined(_WIN32) || defined(_WIN64)
  char invalidChars[] = { '<', '>', ':', '"', '/', '\\', '|', '?', '*',
                          '\0',
                          '\x01', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
                          '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F',
                          '\x10', '\x11', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
                          '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D', '\x1E', '\x1F' };
  #elif defined(__unix__) || defined(__unix)
    #if defined(__APPLE__)
    char invalidChars[] = { '/', ':', '\0' };
    #else
    char invalidChars[] = { '/', '\0' };
    #endif
  #else
  #error Unknow OS.  :-(
  #endif
 
  bool valid = true;
  size_t i = 0;
  while (valid && (i < (sizeof(invalidChars) / sizeof(invalidChars[0]))))
  {
    valid = (filename.find(invalidChars[i]) == string::npos);
    i++;
  }
 
  #if defined(_WIN32) || defined(_WIN64)
  if (valid)
  {
    const char& last = filename.back();  // string is not empty
    if ((last == ' ') || (last == '.'))
      valid = false;
    else
    {
      ArrayString invalidNames;
      invalidNames.emplace_back(string("CON"));
      invalidNames.emplace_back(string("PRN"));
      invalidNames.emplace_back(string("AUX"));
      invalidNames.emplace_back(string("NUL"));
      for (int i = 1; i <= 9; i++)
      {
        char buf[5];
        snprintf(buf, 5, "COM%d", i);
        invalidNames.emplace_back(string(buf));
        snprintf(buf, 5, "LPT%d", i);
        invalidNames.emplace_back(string(buf));
      }
 
      i = 0;
      while (valid && (i < invalidNames.size()))
      {
        valid = (compareFileName(filename, invalidNames[i]) != 0);
        i++;
      }
    }
  }
  #endif
 
  return valid;
}
//---------------------------------------------------------------------------
 
}  // namespace libxcks
//---------------------------------------------------------------------------