diff options
| -rw-r--r-- | butl/path | 39 | ||||
| -rw-r--r-- | butl/path.ixx | 44 | ||||
| -rw-r--r-- | butl/path.txx | 30 |
3 files changed, 57 insertions, 56 deletions
@@ -321,52 +321,53 @@ namespace butl // is, "/" for the root directory and "/tmp" (no trailing slash) for the // rest. This means we can return/store references to path_. // - // Then we have diff_ which is the size difference between path_ and its - // "pure" part, that is, without any trailing slashes, even for "/". So: + // Then we have tsep_ ("trailing separator") which is the size difference + // between path_ and its "pure" part, that is, without any trailing + // slashes, even for "/". So: // - // diff_ == -1 -- trailing slash in path_ (the "/" case) - // diff_ == 0 -- no trailing slash + // tsep_ == -1 -- trailing slash in path_ (the "/" case) + // tsep_ == 0 -- no trailing slash // // Finally, to represent non-root ("/") trailing slashes we use positive - // diff_ values. In this case diff_ is interpreted as a 1-based index in + // tsep_ values. In this case tsep_ is interpreted as a 1-based index in // the path_traits::directory_separators string. // // Notes: - // - If path_ is empty, then diff_ can only be 0. - // - We could have used a much narrower integer for diff_. + // - If path_ is empty, then tsep_ can only be 0. + // - We could have used a much narrower integer for tsep_. // string_type path_; - difference_type diff_; + difference_type tsep_; size_type - _size () const {return path_.size () + (diff_ < 0 ? -1 : 0);} + _size () const {return path_.size () + (tsep_ < 0 ? -1 : 0);} void - _swap (path_data& d) {path_.swap (d.path_); std::swap (diff_, d.diff_);} + _swap (path_data& d) {path_.swap (d.path_); std::swap (tsep_, d.tsep_);} void - _clear () {path_.clear (); diff_ = 0;} + _clear () {path_.clear (); tsep_ = 0;} // Constructors. // - path_data (): diff_ (0) {} + path_data (): tsep_ (0) {} - path_data (string_type&& p, difference_type d) - : path_ (std::move (p)), diff_ (path_.empty () ? 0 : d) {} + path_data (string_type&& p, difference_type ts) + : path_ (std::move (p)), tsep_ (path_.empty () ? 0 : ts) {} explicit path_data (string_type&& p) - : path_ (std::move (p)), diff_ (0) + : path_ (std::move (p)), tsep_ (0) { size_type n (path_.size ()), i; if (n != 0 && (i = path_traits<C>::separator_index (path_[n - 1])) != 0) { if (n == 1) // The "/" case. - diff_ = -1; + tsep_ = -1; else { - diff_ = i; + tsep_ = i; path_.pop_back (); } } @@ -702,8 +703,8 @@ namespace butl { return e_ != string_type::npos ? p_->path_[e_] - : (p_->diff_ > 0 - ? path_traits<C>::directory_separators[p_->diff_ - 1] + : (p_->tsep_ > 0 + ? path_traits<C>::directory_separators[p_->tsep_ - 1] : 0); } diff --git a/butl/path.ixx b/butl/path.ixx index d1fa34c..169f05d 100644 --- a/butl/path.ixx +++ b/butl/path.ixx @@ -43,7 +43,7 @@ namespace butl path_cast_impl (const basic_path<C, K2>& p, basic_path<C, K1>*) { typename basic_path<C, K1>::data_type d ( - typename basic_path<C, K1>::string_type (p.path_), p.diff_); + typename basic_path<C, K1>::string_type (p.path_), p.tsep_); K1::cast (d); return basic_path<C, K1> (std::move (d)); } @@ -52,7 +52,7 @@ namespace butl inline basic_path<C, K1> path_cast_impl (basic_path<C, K2>&& p, basic_path<C, K1>*) { - typename basic_path<C, K1>::data_type d (std::move (p.path_), p.diff_); + typename basic_path<C, K1>::data_type d (std::move (p.path_), p.tsep_); K1::cast (d); return basic_path<C, K1> (std::move (d)); } @@ -166,7 +166,7 @@ namespace butl : string_type::npos); return p != string_type::npos - ? basic_path (data_type (string_type (s, p + 1), this->diff_)) + ? basic_path (data_type (string_type (s, p + 1), this->tsep_)) : *this; } @@ -216,7 +216,7 @@ namespace butl // : (e.b_ != string_type::npos ? data_type (string_type (b.p_->path_, b.b_, e.b_ - b.b_)) - : data_type (string_type (b.p_->path_, b.b_), b.p_->diff_))) + : data_type (string_type (b.p_->path_, b.b_), b.p_->tsep_))) { //assert (b.p_ == e.p_); } @@ -261,7 +261,7 @@ namespace butl ? dir_type ( s.size () > 2 ? data_type (string_type (s, 0, 3)) - : data_type (string_type (s), this->diff_ != 0 ? this->diff_ : 1)) + : data_type (string_type (s), this->tsep_ != 0 ? this->tsep_ : 1)) : dir_type (); #else return absolute () @@ -279,7 +279,7 @@ namespace butl size_type p (traits::find_extension (s)); return p != string_type::npos - ? basic_path (data_type (string_type (s, 0, p), this->diff_)) + ? basic_path (data_type (string_type (s, 0, p), this->tsep_)) : *this; } @@ -324,24 +324,24 @@ namespace butl template <typename C, typename K> inline void basic_path<C, K>:: - combine (const C* r, size_type rn, difference_type rd) + combine (const C* r, size_type rn, difference_type rts) { //assert (rn != 0); string_type& l (this->path_); - difference_type& d (this->diff_); + difference_type& ts (this->tsep_); // Handle the separator. LHS should be empty or already have one. // - switch (d) + switch (ts) { case 0: if (!l.empty ()) throw invalid_basic_path<C> (l); break; case -1: break; // Already in the string. - default: l += path_traits<C>::directory_separators[d - 1]; + default: l += path_traits<C>::directory_separators[ts - 1]; } l.append (r, rn); - d = rd; // New trailing separator from RHS. + ts = rts; // New trailing separator from RHS. } template <typename C, typename K> @@ -372,7 +372,7 @@ namespace butl throw invalid_basic_path<C> (r.path_); if (!r.empty ()) - combine (r.path_.c_str (), r.path_.size (), r.diff_); + combine (r.path_.c_str (), r.path_.size (), r.tsep_); return *this; } @@ -401,7 +401,7 @@ namespace butl inline void basic_path<C, K>:: append (const C* r, size_type rn) { - //assert (this->diff_ != -1); // Append to root? + //assert (this->tsep_ != -1); // Append to root? this->path_.append (r, rn); } @@ -435,8 +435,8 @@ namespace butl { string_type r (this->path_); - if (this->diff_ > 0) - r += path_traits<C>::directory_separators[this->diff_ - 1]; + if (this->tsep_ > 0) + r += path_traits<C>::directory_separators[this->tsep_ - 1]; return r; } @@ -448,8 +448,8 @@ namespace butl string_type r; r.swap (this->path_); - if (this->diff_ > 0) - r += path_traits<C>::directory_separators[this->diff_ - 1]; + if (this->tsep_ > 0) + r += path_traits<C>::directory_separators[this->tsep_ - 1]; return r; } @@ -458,9 +458,9 @@ namespace butl inline C basic_path<C, K>:: separator () const { - return (this->diff_ == 0 ? 0 : - this->diff_ == -1 ? this->path_[0] : - path_traits<C>::directory_separators[this->diff_ - 1]); + return (this->tsep_ == 0 ? 0 : + this->tsep_ == -1 ? this->path_[0] : + path_traits<C>::directory_separators[this->tsep_ - 1]); } template <typename C, typename K> @@ -477,7 +477,7 @@ namespace butl { // Add trailing slash if one isn't already there. // - if (!d.path_.empty () && d.diff_ == 0) - d.diff_ = 1; // Canonical separator is always first. + if (!d.path_.empty () && d.tsep_ == 0) + d.tsep_ = 1; // Canonical separator is always first. } } diff --git a/butl/path.txx b/butl/path.txx index 1653dc0..5bcaea0 100644 --- a/butl/path.txx +++ b/butl/path.txx @@ -28,13 +28,13 @@ namespace butl // If there is implied trailing slash, add it to count. Unless it is // "matched" by the implied slash on the other side. // - if (d.diff_ > 0 && dn < s.size ()) + if (d.tsep_ > 0 && dn < s.size ()) dn++; // Preserve trailing slash. // return basic_path (data_type (string_type (s, dn, s.size () - dn), - this->diff_)); + this->tsep_)); } template <typename C, typename K> @@ -47,10 +47,10 @@ namespace butl if (ln == 0) { - if (this->diff_ == 0) // Must be a directory. + if (this->tsep_ == 0) // Must be a directory. throw invalid_basic_path<C> (s); - return dir_type (data_type (string_type (s), this->diff_)); + return dir_type (data_type (string_type (s), this->tsep_)); } if (!sup (l)) @@ -156,12 +156,12 @@ namespace butl assert (!actual || abs); // Only absolue can be actualized. string_type& s (this->path_); - difference_type& d (this->diff_); + difference_type& ts (this->tsep_); typedef std::vector<string_type> paths; paths ps; - bool tsep (d != 0); // Trailing directory separator. + bool tsep (ts != 0); // Trailing directory separator. { size_type n (_size ()); @@ -278,13 +278,13 @@ namespace butl if (p.empty ()) { p += traits::directory_separator; - d = -1; + ts = -1; } else - d = 1; // Canonical separator is always first. + ts = 1; // Canonical separator is always first. } else - d = 0; + ts = 0; s.swap (p); return *this; @@ -333,7 +333,7 @@ namespace butl m != 0 && (i = path_traits<C>::separator_index (s[m - 1])) != 0; --m) di = i; - difference_type d (0); + difference_type ts (0); if (size_t k = n - m) { // We can only accomodate one trailing slash in the exact mode. @@ -344,15 +344,15 @@ namespace butl if (m == 0) // The "/" case. { ++m; // Keep one slash in the string. - d = -1; + ts = -1; } else - d = di; + ts = di; s.resize (m); } - return data_type (std::move (s), d); + return data_type (std::move (s), ts); } template <typename C> @@ -369,8 +369,8 @@ namespace butl // Unless the result is empty, make sure we have the trailing slash. // - if (!r.path_.empty () && r.diff_ == 0) - r.diff_ = 1; // Canonical separator is always first. + if (!r.path_.empty () && r.tsep_ == 0) + r.tsep_ = 1; // Canonical separator is always first. return r; } |