diff options
Diffstat (limited to 'build/path')
| -rw-r--r-- | build/path | 553 |
1 files changed, 0 insertions, 553 deletions
diff --git a/build/path b/build/path deleted file mode 100644 index f107391..0000000 --- a/build/path +++ /dev/null @@ -1,553 +0,0 @@ -// file : build/path -*- C++ -*- -// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd -// license : MIT; see accompanying LICENSE file - -#ifndef BUILD_PATH -#define BUILD_PATH - -#include <string> -#include <cstddef> // ptrdiff_t -#include <ostream> -#include <utility> // move -#include <iterator> -#include <exception> -#include <functional> // hash - -namespace build -{ - template <typename C> - struct path_traits - { - typedef std::basic_string<C> string_type; - typedef typename string_type::size_type size_type; - - // Canonical directory and path seperators. - // -#ifdef _WIN32 - static C const directory_separator = '\\'; - static C const path_separator = ';'; -#else - static C const directory_separator = '/'; - static C const path_separator = ':'; -#endif - - // Directory separator tests. On some platforms there - // could be multiple seperators. For example, on Windows - // we check for both '/' and '\'. - // - static bool - is_separator (C c) - { -#ifdef _WIN32 - return c == '\\' || c == '/'; -#else - return c == '/'; -#endif - } - - static size_type - find_separator (string_type const& s, size_type pos = 0) - { - for (size_type n (s.size ()); pos < n; ++pos) - { - if (is_separator (s[pos])) - return pos; - } - - return string_type::npos; - } - - static size_type - rfind_separator (string_type const& s, size_type pos = string_type::npos) - { - if (pos == string_type::npos) - pos = s.size (); - else - pos++; - - for (; pos > 0; --pos) - { - if (is_separator (s[pos - 1])) - return pos - 1; - } - - return string_type::npos; - } - - // Return the position of '.' or npos if there is no extension. - // - static size_type - find_extension (string_type const& s) - { - size_type i (s.size ()); - - for (; i > 0; --i) - { - C c (s[i - 1]); - - if (c == '.') - break; - - if (is_separator (c)) - { - i = 0; - break; - } - } - - // Weed out paths like ".txt" (and "/.txt") and "txt.". - // - if (i > 1 && !is_separator (s[i - 2]) && i != s.size ()) - return i - 1; - else - return string_type::npos; - } - - static int - compare (string_type const& l, string_type const& r) - { - size_type ln (l.size ()), rn (r.size ()), n (ln < rn ? ln : rn); - for (size_type i (0); i != n; ++i) - { -#ifdef _WIN32 - C lc (tolower (l[i])), rc (tolower (r[i])); -#else - C lc (l[i]), rc (r[i]); -#endif - if (is_separator (lc) && is_separator (rc)) - continue; - - if (lc < rc) return -1; - if (lc > rc) return 1; - } - - return ln < rn ? -1 : (ln > rn ? 1 : 0); - } - - // Get/set current working directory. Throw std::system_error - // to report the underlying OS errors. - // - static string_type - current (); - - static void - current (string_type const&); - - private: -#ifdef _WIN32 - static C - tolower (C); -#endif - }; - - template <typename C> - class invalid_basic_path; - - template <typename C, typename K> - class basic_path; - - template <typename C> - class path_data; - - template <typename C> - struct dir_path_kind; - - template <typename C> - struct any_path_kind - { - typedef path_data<C> base_type; - typedef basic_path<C, dir_path_kind<C>> dir_type; - }; - - template <typename C> - struct dir_path_kind - { - typedef basic_path<C, any_path_kind<C>> base_type; - typedef basic_path<C, dir_path_kind<C>> dir_type; - }; - - typedef basic_path<char, any_path_kind<char>> path; - typedef basic_path<char, dir_path_kind<char>> dir_path; - typedef invalid_basic_path<char> invalid_path; - - typedef basic_path<wchar_t, any_path_kind<wchar_t>> wpath; - typedef basic_path<wchar_t, dir_path_kind<wchar_t>> dir_wpath; - typedef invalid_basic_path<wchar_t> invalid_wpath; - - // - // - class invalid_path_base: std::exception - { - public: - virtual char const* - what () const throw (); - }; - - template <typename C> - class invalid_basic_path: public invalid_path_base - { - public: - typedef std::basic_string<C> string_type; - - invalid_basic_path (C const* p): path_ (p) {} - invalid_basic_path (string_type const& p): path_ (p) {} - ~invalid_basic_path () throw () {} - - string_type const& - path () const - { - return path_; - } - - private: - string_type path_; - }; - - template <typename C> - class path_data - { - public: - typedef std::basic_string<C> string_type; - - path_data () = default; - - explicit - path_data (string_type s): path_ (std::move (s)) {} - - protected: - string_type path_; - }; - - template <typename C, typename K> - class basic_path: public K::base_type - { - public: - typedef std::basic_string<C> string_type; - typedef typename string_type::size_type size_type; - - typedef typename K::base_type base_type; - typedef typename K::dir_type dir_type; - - typedef path_traits<C> traits; - - // Construct special empty path. Note that we have to provide our - // own implementation rather than using '=default' to make clang - // allow default-initialized const instances of this type. - // - basic_path () {}; - - explicit - basic_path (C const* s): base_type (s) {init ();} - - basic_path (C const* s, size_type n) - : base_type (string_type (s, n)) {init ();} - - explicit - basic_path (string_type s): base_type (std::move (s)) {init ();} - - basic_path (const string_type& s, size_type n) - : base_type (string_type (s, 0, n)) {init ();} - - basic_path (const string_type& s, size_type p, size_type n) - : base_type (string_type (s, p, n)) {init ();} - - void - swap (basic_path& p) - { - this->path_.swap (p.path_); - } - - void - clear () - { - this->path_.clear (); - } - - // Get/set current working directory. Throw std::system_error - // to report the underlying OS errors. - // - static dir_type - current () {return dir_type (traits::current ());} - - static void - current (basic_path const&); - - public: - bool - empty () const - { - return this->path_.empty (); - } - - bool - absolute () const; - - bool - relative () const - { - return !absolute (); - } - - bool - root () const; - - // Return true if *this is a sub-path of the specified path (i.e., - // the specified path is a prefix). Expects both paths to be - // normalized. Note that this function returns true if the paths - // are equal. Empty path is considered a prefix of any path. - // - bool - sub (const basic_path&) const; - - // Return true if *this is a super-path of the specified path (i.e., - // the specified path is a suffix). Expects both paths to be - // normalized. Note that this function returns true if the paths - // are equal. Empty path is considered a suffix of any path. - // - bool - sup (const basic_path&) const; - - public: - // Return the path without the directory part. - // - basic_path - leaf () const; - - // Return the path without the specified directory part. Throws - // invalid_path if the directory is not a prefix of *this. Expects - // both paths to be normalized. - // - basic_path - leaf (basic_path const&) const; - - // Return the directory part of the path or empty path if - // there is no directory. - // - dir_type - directory () const; - - // Return the directory part of the path without the specified - // leaf part. Throws invalid_path if the leaf is not a suffix of - // *this. Expects both paths to be normalized. - // - dir_type - directory (basic_path const&) const; - - // Return the root directory of the path or empty path if - // the directory is not absolute. - // - dir_type - root_directory () const; - - // Return the path without the extension, if any. - // - basic_path - base () const; - - // Return the extension or NULL if not present. - // - const C* - extension () const; - - // Return a path relative to the specified path that is equivalent - // to *this. Throws invalid_path if a relative path cannot be derived - // (e.g., paths are on different drives on Windows). - // - basic_path - relative (basic_path) const; - - // Iteration over path components. - // - public: - struct iterator - { - typedef string_type value_type; - typedef string_type* pointer; - typedef string_type& reference; - typedef std::ptrdiff_t difference_type; - typedef std::forward_iterator_tag iterator_category; - - typedef typename string_type::size_type size_type; - - iterator (): p_ (nullptr) {} - iterator (const string_type& p, size_type b, size_type e) - : p_ (&p), b_ (b), e_ (e) {} - - iterator& - operator++ () - { - b_ = e_; - - if (b_ != string_type::npos) - e_ = traits::find_separator (*p_, ++b_); - - return *this; - } - - iterator - operator++ (int) {iterator r (*this); return ++r;} - - string_type operator* () const - { - return string_type (*p_, b_, (e_ != string_type::npos ? e_ - b_ : e_)); - } - - friend bool - operator== (const iterator& x, const iterator& y) - { - return x.p_ == y.p_ && x.b_ == y.b_ && x.e_ == y.e_; - } - - friend bool - operator!= (const iterator& x, const iterator& y) {return !(x == y);} - - private: - // b != npos && e == npos - last component - // b == npos && e == npos - one past last component (end) - // - const string_type* p_; - size_type b_; - size_type e_; - }; - - iterator begin () const; - iterator end () const; - - public: - // Normalize the path. This includes collapsing the '.' and '..' - // directories if possible, collapsing multiple directory - // separators, and converting all directory separators to the - // canonical form. Returns *this. - // - basic_path& - normalize (); - - // Make the path absolute using the current directory unless - // it is already absolute. - // - basic_path& - complete (); - - public: - basic_path& - operator/= (basic_path const&); - - basic_path - operator+ (string_type const& s) const - { - return basic_path (this->path_ + s); - } - - basic_path - operator+ (C c) const - { - return basic_path (this->path_ + c); - } - - basic_path& - operator+= (string_type const& s) - { - this->path_ += s; - return *this; - } - - basic_path& - operator+= (C c) - { - this->path_ += c; - return *this; - } - - // Note that comparison is case-insensitive if the filesystem is - // not case-sensitive (e.g., Windows). - // - bool - operator== (basic_path const& x) const - { - return traits::compare (this->path_, x.path_) == 0; - } - - bool - operator!= (basic_path const& x) const - { - return !(*this == x); - } - - bool - operator< (basic_path const& x) const - { - return traits::compare (this->path_, x.path_) < 0; - } - - public: - const string_type& - string () const - { - return this->path_; - } - - // If possible, return a POSIX representation of the path. For example, - // for a Windows path in the form foo\bar this function will return - // foo/bar. If it is not possible to create a POSIX representation for - // this path (e.g., c:\foo), this function will throw the invalid_path - // exception. - // - string_type - posix_string () const; - - private: - void - init (); - }; - - template <typename C, typename K> - inline basic_path<C, K> - operator/ (basic_path<C, K> const& x, basic_path<C, K> const& y) - { - basic_path<C, K> r (x); - r /= y; - return r; - } - - // Additional operators for certain path kind combinations. - // - template <typename C> - inline basic_path<C, any_path_kind<C>> - operator/ (basic_path<C, dir_path_kind<C>> const& x, - basic_path<C, any_path_kind<C>> const& y) - { - basic_path<C, any_path_kind<C>> r (x); - r /= y; - return r; - } - - // IO - // - - /* - template <typename C, typename K> - inline std::basic_ostream<C>& - operator<< (std::basic_ostream<C>& os, basic_path<C, K> const& p) - { - return os << p.string (); - } - */ -} - -namespace std -{ - template <typename C, typename K> - struct hash<build::basic_path<C, K>>: hash<basic_string<C>> - { - size_t - operator() (const build::basic_path<C, K>& p) const noexcept - { - return hash<basic_string<C>>::operator() (p.string ()); - } - }; -} - -#include <build/path.ixx> -#include <build/path.txx> - -#endif // BUILD_PATH |