mirror of
https://github.com/DarkStore-3DS/Project_CTR.git
synced 2026-07-04 16:59:02 +00:00
Move dependencies to the top level.
This commit is contained in:
jakcron
@@ -1,331 +0,0 @@
|
||||
|
||||
#include <tc/io/Path.h>
|
||||
#include <tc/string.h>
|
||||
#include <tc/Exception.h>
|
||||
|
||||
#include <fmt/core.h>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <regex>
|
||||
|
||||
static const char kWindowsPathSeparator = '\\'; /**< Path separator used on Microsoft Windows based systems */
|
||||
static const char kPosixPathSeparator = '/'; /**< Path separator used on POSIX based systems */
|
||||
#ifdef _WIN32
|
||||
static const char kNativePathSeparator = kWindowsPathSeparator; /**< Path separator for the native environment */
|
||||
#else
|
||||
static const char kNativePathSeparator = kPosixPathSeparator; /**< Path separator for the native environment */
|
||||
#endif
|
||||
|
||||
const std::string tc::io::Path::kClassName = "tc::io::Path";
|
||||
|
||||
tc::io::Path::Path()
|
||||
{}
|
||||
|
||||
tc::io::Path::Path(std::initializer_list<std::string> list) :
|
||||
mUnicodePath(list)
|
||||
{
|
||||
}
|
||||
|
||||
tc::io::Path::Path(const std::string& path)
|
||||
{
|
||||
initializePath(path);
|
||||
}
|
||||
|
||||
tc::io::Path::Path(const std::u16string& path)
|
||||
{
|
||||
std::string utf8_path;
|
||||
string::TranscodeUtil::UTF16ToUTF8(path, utf8_path);
|
||||
initializePath(utf8_path);
|
||||
}
|
||||
|
||||
tc::io::Path::Path(const std::u32string& path)
|
||||
{
|
||||
std::string utf8_path;
|
||||
string::TranscodeUtil::UTF32ToUTF8(path, utf8_path);
|
||||
initializePath(utf8_path);
|
||||
}
|
||||
|
||||
tc::io::Path tc::io::Path::operator+(const Path& other) const
|
||||
{
|
||||
Path new_path = *this;
|
||||
new_path.appendPath(other.mUnicodePath);
|
||||
return new_path;
|
||||
}
|
||||
|
||||
void tc::io::Path::operator+=(const Path& other)
|
||||
{
|
||||
appendPath(other.mUnicodePath);
|
||||
}
|
||||
|
||||
bool tc::io::Path::operator==(const Path& other) const
|
||||
{
|
||||
return mUnicodePath == other.mUnicodePath;
|
||||
}
|
||||
|
||||
bool tc::io::Path::operator!=(const Path& other) const
|
||||
{
|
||||
return !(this->operator==(other));
|
||||
}
|
||||
|
||||
bool tc::io::Path::operator<(const Path& other) const
|
||||
{
|
||||
int cmp_score = 0;
|
||||
|
||||
auto self_itr = this->begin();
|
||||
auto other_itr = other.begin();
|
||||
|
||||
// in this loop for as long as both path has an itr, it'll compare them
|
||||
for (; self_itr != this->end() && other_itr != other.end(); self_itr++, other_itr++)
|
||||
{
|
||||
cmp_score = self_itr->compare(*other_itr);
|
||||
if (cmp_score != 0)
|
||||
break;
|
||||
}
|
||||
|
||||
// if one of the itrs isn't the end, then that one is "larger"
|
||||
// it can't be both or the prior loop won't have ended
|
||||
if (cmp_score == 0 && (self_itr != this->end() || other_itr != other.end()))
|
||||
{
|
||||
cmp_score = self_itr == this->end() ? -1 : 1;
|
||||
}
|
||||
|
||||
return cmp_score < 0;
|
||||
}
|
||||
|
||||
tc::io::Path::iterator tc::io::Path::begin()
|
||||
{
|
||||
return mUnicodePath.begin();
|
||||
}
|
||||
|
||||
std::string& tc::io::Path::front()
|
||||
{
|
||||
return mUnicodePath.front();
|
||||
}
|
||||
|
||||
const std::string& tc::io::Path::front() const
|
||||
{
|
||||
return mUnicodePath.front();
|
||||
}
|
||||
|
||||
std::string& tc::io::Path::back()
|
||||
{
|
||||
return mUnicodePath.back();
|
||||
}
|
||||
|
||||
const std::string& tc::io::Path::back() const
|
||||
{
|
||||
return mUnicodePath.back();
|
||||
}
|
||||
|
||||
tc::io::Path::const_iterator tc::io::Path::begin() const
|
||||
{
|
||||
return mUnicodePath.begin();
|
||||
}
|
||||
|
||||
tc::io::Path::iterator tc::io::Path::end()
|
||||
{
|
||||
return mUnicodePath.end();
|
||||
}
|
||||
|
||||
tc::io::Path::const_iterator tc::io::Path::end() const
|
||||
{
|
||||
return mUnicodePath.end();
|
||||
}
|
||||
|
||||
void tc::io::Path::pop_front()
|
||||
{
|
||||
mUnicodePath.pop_front();
|
||||
}
|
||||
|
||||
void tc::io::Path::pop_back()
|
||||
{
|
||||
mUnicodePath.pop_back();
|
||||
}
|
||||
|
||||
void tc::io::Path::push_front(const std::string& str)
|
||||
{
|
||||
mUnicodePath.push_front(str);
|
||||
}
|
||||
|
||||
void tc::io::Path::push_back(const std::string& str)
|
||||
{
|
||||
mUnicodePath.push_back(str);
|
||||
}
|
||||
|
||||
void tc::io::Path::clear()
|
||||
{
|
||||
mUnicodePath.clear();
|
||||
}
|
||||
|
||||
size_t tc::io::Path::size() const
|
||||
{
|
||||
return mUnicodePath.size();
|
||||
}
|
||||
|
||||
bool tc::io::Path::empty() const
|
||||
{
|
||||
return mUnicodePath.empty();
|
||||
}
|
||||
|
||||
tc::io::Path tc::io::Path::subpath(size_t pos, size_t len) const
|
||||
{
|
||||
tc::io::Path out_path;
|
||||
|
||||
auto itr = begin();
|
||||
size_t index = 0;
|
||||
|
||||
// while the out_path size is less than len and the iterator hasn't ended
|
||||
while ( out_path.size() < len && itr != end() )
|
||||
{
|
||||
// provided the index >= pos save the element
|
||||
if (index >= pos)
|
||||
{
|
||||
out_path.push_back(*itr);
|
||||
}
|
||||
|
||||
itr++;
|
||||
index++;
|
||||
}
|
||||
|
||||
return out_path;
|
||||
}
|
||||
|
||||
tc::io::Path tc::io::Path::subpath(const_iterator begin, const_iterator end) const
|
||||
{
|
||||
tc::io::Path out_path;
|
||||
|
||||
for (auto itr = begin; itr != end && itr != this->end(); itr++)
|
||||
{
|
||||
out_path.push_back(*itr);
|
||||
}
|
||||
|
||||
return out_path;
|
||||
}
|
||||
|
||||
std::string tc::io::Path::to_string(Format format) const
|
||||
{
|
||||
std::string path_str = "";
|
||||
|
||||
if (format == Path::Format::Native)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
format = Path::Format::Win32;
|
||||
#else
|
||||
format = Path::Format::POSIX;
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string path_separator_str;
|
||||
switch (format)
|
||||
{
|
||||
case (Path::Format::POSIX):
|
||||
path_separator_str = fmt::format("{:c}", kPosixPathSeparator);
|
||||
break;
|
||||
case (Path::Format::Win32):
|
||||
path_separator_str = fmt::format("{:c}", kWindowsPathSeparator);
|
||||
break;
|
||||
default:
|
||||
throw tc::ArgumentException(kClassName, "Invalid Format type.");
|
||||
}
|
||||
|
||||
// special case where the path has one element and its the root path
|
||||
if (this->size() == 1)
|
||||
{
|
||||
// for POSIX style this is the empty string ("/")
|
||||
if (format == Path::Format::POSIX && this->front() == "")
|
||||
return path_separator_str;
|
||||
// for Win32 style this is a drive letter followed by ':' e.g. ("C:\")
|
||||
else if (format == Path::Format::Win32 && std::regex_match(this->front(), std::regex("^([A-Z,a-z]):")))
|
||||
return fmt::format("{}{}", this->front(), path_separator_str);
|
||||
}
|
||||
|
||||
for (const_iterator itr = this->begin(); itr != this->end(); itr++)
|
||||
{
|
||||
path_str += *itr;
|
||||
// don't print path separator where it would be trailing character
|
||||
if (itr != --(this->end()))
|
||||
path_str += path_separator_str;
|
||||
}
|
||||
|
||||
return path_str;
|
||||
}
|
||||
|
||||
std::u16string tc::io::Path::to_u16string(Format format) const
|
||||
{
|
||||
std::string u8string = to_string(format);
|
||||
std::u16string u16string;
|
||||
|
||||
// convert
|
||||
string::TranscodeUtil::UTF8ToUTF16(u8string, u16string);
|
||||
|
||||
// return
|
||||
return u16string;
|
||||
}
|
||||
|
||||
std::u32string tc::io::Path::to_u32string(Format format) const
|
||||
{
|
||||
std::string u8string = to_string(format);
|
||||
std::u32string u32string;
|
||||
|
||||
// convert
|
||||
string::TranscodeUtil::UTF8ToUTF32(u8string, u32string);
|
||||
|
||||
// return
|
||||
return u32string;
|
||||
}
|
||||
|
||||
tc::io::Path::operator std::string() const
|
||||
{
|
||||
return to_string(Format::Native);
|
||||
}
|
||||
|
||||
tc::io::Path::operator std::u16string() const
|
||||
{
|
||||
return to_u16string(Format::Native);
|
||||
}
|
||||
|
||||
tc::io::Path::operator std::u32string() const
|
||||
{
|
||||
return to_u32string(Format::Native);
|
||||
}
|
||||
|
||||
void tc::io::Path::initializePath(const std::string& src)
|
||||
{
|
||||
size_t windows_slash_count = 0;
|
||||
size_t posix_slash_count = 0;
|
||||
for (size_t i = 0; i < src.size(); i++)
|
||||
{
|
||||
if (src[i] == kWindowsPathSeparator)
|
||||
windows_slash_count += 1;
|
||||
else if (src[i] == kPosixPathSeparator)
|
||||
posix_slash_count += 1;
|
||||
}
|
||||
|
||||
if (windows_slash_count != 0 && posix_slash_count != 0)
|
||||
{
|
||||
throw tc::ArgumentException(kClassName, "Path literal has both forward ('/') and backward ('\\') path separators.");
|
||||
}
|
||||
|
||||
char path_delimiter = kNativePathSeparator;
|
||||
if (windows_slash_count > 0)
|
||||
path_delimiter = kWindowsPathSeparator;
|
||||
else if (posix_slash_count > 0)
|
||||
path_delimiter = kPosixPathSeparator;
|
||||
|
||||
|
||||
std::stringstream src_stream(src);
|
||||
|
||||
std::string element;
|
||||
while (std::getline(src_stream, element, path_delimiter))
|
||||
{
|
||||
mUnicodePath.push_back(element);
|
||||
}
|
||||
}
|
||||
|
||||
void tc::io::Path::appendPath(const std::list<std::string>& other)
|
||||
{
|
||||
for (std::list<std::string>::const_iterator itr = other.begin(); itr != other.end(); itr++)
|
||||
{
|
||||
mUnicodePath.push_back(*itr);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user