From 0a6c4c31b2a9e79c9c0119202f9e50e123f98ac6 Mon Sep 17 00:00:00 2001 From: Denis Krjuchkov Date: Thu, 5 Dec 2013 03:53:43 +0600 Subject: fs/Traits: split PathTraits type into PathTraitsFS and PathTraitsUTF8 --- src/fs/AllocatedPath.cxx | 6 ++--- src/fs/AllocatedPath.hxx | 20 +++++++-------- src/fs/FileSystem.hxx | 14 +++++------ src/fs/Path.cxx | 4 +-- src/fs/Path.hxx | 8 +++--- src/fs/Traits.cxx | 20 +++++++-------- src/fs/Traits.hxx | 65 ++++++++++++++++++++++++++---------------------- 7 files changed, 71 insertions(+), 66 deletions(-) (limited to 'src/fs') diff --git a/src/fs/AllocatedPath.cxx b/src/fs/AllocatedPath.cxx index 5da748ea8..9dc7a644c 100644 --- a/src/fs/AllocatedPath.cxx +++ b/src/fs/AllocatedPath.cxx @@ -75,14 +75,14 @@ AllocatedPath::RelativeFS(const char *other_fs) const other_fs += l; if (*other_fs != 0) { - if (!PathTraits::IsSeparatorFS(*other_fs)) + if (!PathTraitsFS::IsSeparator(*other_fs)) /* mismatch */ return nullptr; /* skip remaining path separators */ do { ++other_fs; - } while (PathTraits::IsSeparatorFS(*other_fs)); + } while (PathTraitsFS::IsSeparator(*other_fs)); } return other_fs; @@ -94,7 +94,7 @@ AllocatedPath::ChopSeparators() size_t l = length(); const char *p = data(); - while (l >= 2 && PathTraits::IsSeparatorFS(p[l - 1])) { + while (l >= 2 && PathTraitsFS::IsSeparator(p[l - 1])) { --l; #if GCC_CHECK_VERSION(4,7) && !defined(__clang__) diff --git a/src/fs/AllocatedPath.hxx b/src/fs/AllocatedPath.hxx index bc69bc618..d44953cd6 100644 --- a/src/fs/AllocatedPath.hxx +++ b/src/fs/AllocatedPath.hxx @@ -37,10 +37,10 @@ class Error; * stored. */ class AllocatedPath { - typedef PathTraits::string string; - typedef PathTraits::value_type value_type; - typedef PathTraits::pointer pointer; - typedef PathTraits::const_pointer const_pointer; + typedef PathTraitsFS::string string; + typedef PathTraitsFS::value_type value_type; + typedef PathTraitsFS::pointer pointer; + typedef PathTraitsFS::const_pointer const_pointer; string value; @@ -57,7 +57,7 @@ class AllocatedPath { static AllocatedPath Build(const_pointer a, size_t a_size, const_pointer b, size_t b_size) { - return AllocatedPath(PathTraits::BuildFS(a, a_size, b, b_size)); + return AllocatedPath(PathTraitsFS::Build(a, a_size, b, b_size)); } public: /** @@ -93,20 +93,20 @@ public: */ gcc_pure gcc_nonnull_all static AllocatedPath Build(const_pointer a, const_pointer b) { - return Build(a, PathTraits::GetLengthFS(a), - b, PathTraits::GetLengthFS(b)); + return Build(a, PathTraitsFS::GetLength(a), + b, PathTraitsFS::GetLength(b)); } gcc_pure gcc_nonnull_all static AllocatedPath Build(const_pointer a, const AllocatedPath &b) { - return Build(a, PathTraits::GetLengthFS(a), + return Build(a, PathTraitsFS::GetLength(a), b.value.c_str(), b.value.size()); } gcc_pure gcc_nonnull_all static AllocatedPath Build(const AllocatedPath &a, const_pointer b) { return Build(a.value.c_str(), a.value.size(), - b, PathTraits::GetLengthFS(b)); + b, PathTraitsFS::GetLength(b)); } gcc_pure @@ -233,7 +233,7 @@ public: gcc_pure bool IsAbsolute() { - return PathTraits::IsAbsoluteFS(c_str()); + return PathTraitsFS::IsAbsolute(c_str()); } }; diff --git a/src/fs/FileSystem.hxx b/src/fs/FileSystem.hxx index 67c6eef3e..b4dd01cd3 100644 --- a/src/fs/FileSystem.hxx +++ b/src/fs/FileSystem.hxx @@ -36,39 +36,39 @@ namespace FOpenMode { /** * Open mode for reading text files. */ - constexpr PathTraits::const_pointer ReadText = "r"; + constexpr PathTraitsFS::const_pointer ReadText = "r"; /** * Open mode for reading binary files. */ - constexpr PathTraits::const_pointer ReadBinary = "rb"; + constexpr PathTraitsFS::const_pointer ReadBinary = "rb"; /** * Open mode for writing text files. */ - constexpr PathTraits::const_pointer WriteText = "w"; + constexpr PathTraitsFS::const_pointer WriteText = "w"; /** * Open mode for writing binary files. */ - constexpr PathTraits::const_pointer WriteBinary = "wb"; + constexpr PathTraitsFS::const_pointer WriteBinary = "wb"; /** * Open mode for appending text files. */ - constexpr PathTraits::const_pointer AppendText = "a"; + constexpr PathTraitsFS::const_pointer AppendText = "a"; /** * Open mode for appending binary files. */ - constexpr PathTraits::const_pointer AppendBinary = "ab"; + constexpr PathTraitsFS::const_pointer AppendBinary = "ab"; } /** * Wrapper for fopen() that uses #Path names. */ static inline FILE * -FOpen(Path file, PathTraits::const_pointer mode) +FOpen(Path file, PathTraitsFS::const_pointer mode) { return fopen(file.c_str(), mode); } diff --git a/src/fs/Path.cxx b/src/fs/Path.cxx index 0ff0591fb..4b7fb9319 100644 --- a/src/fs/Path.cxx +++ b/src/fs/Path.cxx @@ -36,14 +36,14 @@ Path::RelativeFS(const char *other_fs) const other_fs += l; if (*other_fs != 0) { - if (!PathTraits::IsSeparatorFS(*other_fs)) + if (!PathTraitsFS::IsSeparator(*other_fs)) /* mismatch */ return nullptr; /* skip remaining path separators */ do { ++other_fs; - } while (PathTraits::IsSeparatorFS(*other_fs)); + } while (PathTraitsFS::IsSeparator(*other_fs)); } return other_fs; diff --git a/src/fs/Path.hxx b/src/fs/Path.hxx index 296f4b286..807677f38 100644 --- a/src/fs/Path.hxx +++ b/src/fs/Path.hxx @@ -36,9 +36,9 @@ * instance lives, the string must not be invalidated. */ class Path { - typedef PathTraits::value_type value_type; - typedef PathTraits::pointer pointer; - typedef PathTraits::const_pointer const_pointer; + typedef PathTraitsFS::value_type value_type; + typedef PathTraitsFS::pointer pointer; + typedef PathTraitsFS::const_pointer const_pointer; const char *value; @@ -139,7 +139,7 @@ public: gcc_pure bool IsAbsolute() { - return PathTraits::IsAbsoluteFS(c_str()); + return PathTraitsFS::IsAbsolute(c_str()); } }; diff --git a/src/fs/Traits.cxx b/src/fs/Traits.cxx index aaf0a59e1..3bbc67c5b 100644 --- a/src/fs/Traits.cxx +++ b/src/fs/Traits.cxx @@ -22,9 +22,9 @@ #include -PathTraits::string -PathTraits::BuildFS(PathTraits::const_pointer a, size_t a_size, - PathTraits::const_pointer b, size_t b_size) +PathTraitsFS::string +PathTraitsFS::Build(PathTraitsFS::const_pointer a, size_t a_size, + PathTraitsFS::const_pointer b, size_t b_size) { assert(a != nullptr); assert(b != nullptr); @@ -36,10 +36,10 @@ PathTraits::BuildFS(PathTraits::const_pointer a, size_t a_size, string result(a, a_size); - if (!IsSeparatorFS(a[a_size - 1])) - result.push_back(SEPARATOR_FS); + if (!IsSeparator(a[a_size - 1])) + result.push_back(SEPARATOR); - if (IsSeparatorFS(b[0])) + if (IsSeparator(b[0])) result.append(b + 1, b_size - 1); else result.append(b, b_size); @@ -48,22 +48,22 @@ PathTraits::BuildFS(PathTraits::const_pointer a, size_t a_size, } const char * -PathTraits::GetBaseUTF8(const char *p) +PathTraitsUTF8::GetBase(const char *p) { assert(p != nullptr); - const char *slash = strrchr(p, SEPARATOR_UTF8); + const char *slash = strrchr(p, SEPARATOR); return slash != nullptr ? slash + 1 : p; } std::string -PathTraits::GetParentUTF8(const char *p) +PathTraitsUTF8::GetParent(const char *p) { assert(p != nullptr); - const char *slash = strrchr(p, SEPARATOR_UTF8); + const char *slash = strrchr(p, SEPARATOR); return slash != nullptr ? std::string(p, slash) : std::string("."); diff --git a/src/fs/Traits.hxx b/src/fs/Traits.hxx index 4eb0f24b9..9e8333238 100644 --- a/src/fs/Traits.hxx +++ b/src/fs/Traits.hxx @@ -33,56 +33,40 @@ #include /** - * This class describes the nature of a filesystem path. + * This class describes the nature of a native filesystem path. */ -struct PathTraits { +struct PathTraitsFS { typedef std::string string; typedef char value_type; typedef char *pointer; typedef const char *const_pointer; #ifdef WIN32 - static constexpr value_type SEPARATOR_FS = '\\'; + static constexpr value_type SEPARATOR = '\\'; #else - static constexpr value_type SEPARATOR_FS = '/'; + static constexpr value_type SEPARATOR = '/'; #endif - static constexpr char SEPARATOR_UTF8 = '/'; - - static constexpr bool IsSeparatorFS(value_type ch) { + static constexpr bool IsSeparator(value_type ch) { return #ifdef WIN32 ch == '/' || #endif - ch == SEPARATOR_FS; - } - - static constexpr bool IsSeparatorUTF8(char ch) { - return ch == SEPARATOR_UTF8; - } - - gcc_pure - static bool IsAbsoluteFS(const_pointer p) { - assert(p != nullptr); -#ifdef WIN32 - if (IsAlphaASCII(p[0]) && p[1] == ':' && IsSeparatorFS(p[2])) - return true; -#endif - return IsSeparatorFS(*p); + ch == SEPARATOR; } gcc_pure - static bool IsAbsoluteUTF8(const char *p) { + static bool IsAbsolute(const_pointer p) { assert(p != nullptr); #ifdef WIN32 - if (IsAlphaASCII(p[0]) && p[1] == ':' && IsSeparatorUTF8(p[2])) + if (IsAlphaASCII(p[0]) && p[1] == ':' && IsSeparator(p[2])) return true; #endif - return IsSeparatorUTF8(*p); + return IsSeparator(*p); } gcc_pure - static size_t GetLengthFS(const_pointer p) { + static size_t GetLength(const_pointer p) { return strlen(p); } @@ -93,15 +77,36 @@ struct PathTraits { * If both components are empty strings, empty string is returned. */ gcc_pure gcc_nonnull_all - static string BuildFS(const_pointer a, size_t a_size, - const_pointer b, size_t b_size); + static string Build(const_pointer a, size_t a_size, + const_pointer b, size_t b_size); +}; + +/** + * This class describes the nature of a MPD internal filesystem path. + */ +struct PathTraitsUTF8 { + static constexpr char SEPARATOR = '/'; + + static constexpr bool IsSeparator(char ch) { + return ch == SEPARATOR; + } + + gcc_pure + static bool IsAbsolute(const char *p) { + assert(p != nullptr); +#ifdef WIN32 + if (IsAlphaASCII(p[0]) && p[1] == ':' && IsSeparator(p[2])) + return true; +#endif + return IsSeparator(*p); + } /** * Determine the "base" file name of the given UTF-8 path. * The return value points inside the given string. */ gcc_pure gcc_nonnull_all - static const char *GetBaseUTF8(const char *p); + static const char *GetBase(const char *p); /** * Determine the "parent" file name of the given UTF-8 path. @@ -109,7 +114,7 @@ struct PathTraits { * separator in the given input string. */ gcc_pure gcc_nonnull_all - static std::string GetParentUTF8(const char *p); + static std::string GetParent(const char *p); }; #endif -- cgit v1.2.3