diff options
Diffstat (limited to 'libcutl/cutl/fs/path.txx')
| -rw-r--r-- | libcutl/cutl/fs/path.txx | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/libcutl/cutl/fs/path.txx b/libcutl/cutl/fs/path.txx new file mode 100644 index 0000000..e95c890 --- /dev/null +++ b/libcutl/cutl/fs/path.txx @@ -0,0 +1,216 @@ +// file : cutl/fs/path.txx +// copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC +// license : MIT; see accompanying LICENSE file + +#include <vector> + +namespace cutl +{ + namespace fs + { + template <typename C> + basic_path<C> basic_path<C>:: + leaf () const + { + size_type p (traits::rfind_separator (path_)); + + return p != string_type::npos + ? basic_path (path_.c_str () + p + 1, path_.size () - p - 1) + : *this; + } + + template <typename C> + basic_path<C> basic_path<C>:: + directory () const + { + if (root ()) + return basic_path (); + + size_type p (traits::rfind_separator (path_)); + + // Include the trailing slash so that we get correct behavior + // if directory is root. + // + return p != string_type::npos + ? basic_path (path_.c_str (), p + 1) + : basic_path (); + } + + template <typename C> + basic_path<C> basic_path<C>:: + base () const + { + size_type i (path_.size ()); + + for (; i > 0; --i) + { + if (path_[i - 1] == '.') + break; + + if (traits::is_separator (path_[i - 1])) + { + i = 0; + break; + } + } + + // Weed out paths like ".txt" and "/.txt" + // + if (i > 1 && !traits::is_separator (path_[i - 2])) + { + return basic_path (path_.c_str (), i - 1); + } + else + return *this; + } + +#ifdef _WIN32 + template <typename C> + typename basic_path<C>::string_type basic_path<C>:: + posix_string () const + { + if (absolute ()) + throw invalid_basic_path<C> (path_); + + string_type r (path_); + + // Translate Windows-style separators to the POSIX ones. + // + for (size_type i (0), n (r.size ()); i != n; ++i) + if (r[i] == '\\') + r[i] = '/'; + + return r; + } +#endif + + template <typename C> + basic_path<C>& basic_path<C>:: + operator/= (basic_path<C> const& r) + { + if (r.absolute ()) + throw invalid_basic_path<C> (r.path_); + + if (path_.empty () || r.path_.empty ()) + { + path_ += r.path_; + return *this; + } + + if (!traits::is_separator (path_[path_.size () - 1])) + path_ += traits::directory_separator; + + path_ += r.path_; + + return *this; + } + + template <typename C> + basic_path<C>& basic_path<C>:: + normalize () + { + if (empty ()) + return *this; + + bool abs (absolute ()); + + typedef std::vector<string_type> paths; + paths ps; + + for (size_type b (0), e (traits::find_separator (path_)), + n (path_.size ());; + e = traits::find_separator (path_, b)) + { + string_type s (path_, b, e == string_type::npos ? e : e - b); + ps.push_back (s); + + if (e == string_type::npos) + break; + + ++e; + + while (e < n && traits::is_separator (path_[e])) + ++e; + + if (e == n) + break; + + b = e; + } + + // First collapse '.' and '..'. + // + paths r; + + for (typename paths::const_iterator i (ps.begin ()), e (ps.end ()); + i != e; ++i) + { + string_type const& s (*i); + size_type n (s.size ()); + + if (n == 1 && s[0] == '.') + continue; + + if (n == 2 && s[0] == '.' && s[1] == '.') + { + // Pop the last directory from r unless it is '..'. + // + if (!r.empty ()) + { + string_type const& s1 (r.back ()); + + if (!(s1.size () == 2 && s1[0] == '.' && s1[1] == '.')) + { + // Cannot go past the root directory. + // + if (abs && r.size () == 1) + throw invalid_basic_path<C> (path_); + + r.pop_back (); + continue; + } + } + } + + r.push_back (s); + } + + // Reassemble the path. + // + string_type p; + + for (typename paths::const_iterator i (r.begin ()), e (r.end ()); + i != e;) + { +#ifdef _WIN32 + for (size_type j (0), n (i->size ()); j < n; ++j) + p += tolower ((*i)[j]); +#else + p += *i; +#endif + ++i; + + if (i != e) + p += traits::directory_separator; + } + + if (p.empty () && !r.empty ()) + p += traits::directory_separator; // Root directory. + + path_.swap (p); + return *this; + } + + template <typename C> + void basic_path<C>:: + init () + { + // Strip trailing slashes except for the case where the single + // slash represents the root directory. + // + size_type n (path_.size ()); + for (; n > 1 && traits::is_separator (path_[n - 1]); --n) ; + path_.resize (n); + } + } +} |