diff options
Diffstat (limited to 'libxsde/xsde/cxx/hybrid/sequence.ixx')
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/sequence.ixx | 881 |
1 files changed, 881 insertions, 0 deletions
diff --git a/libxsde/xsde/cxx/hybrid/sequence.ixx b/libxsde/xsde/cxx/hybrid/sequence.ixx new file mode 100644 index 0000000..c1566d2 --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/sequence.ixx @@ -0,0 +1,881 @@ +// file : xsde/cxx/hybrid/sequence.ixx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <new> // placement new + +namespace xsde +{ + namespace cxx + { + namespace hybrid + { + // + // pod_seq + // + + template <typename T> + inline size_t pod_seq<T>:: + max_size () const + { + return size_t (-1) / sizeof (T); + } + + template <typename T> + inline void pod_seq<T>:: + swap (pod_seq& x) + { + swap_ (x); + } + + template <typename T> + inline T* pod_seq<T>:: + begin () + { + return static_cast<T*> (data_); + } + + template <typename T> + inline const T* pod_seq<T>:: + begin () const + { + // g++ 2.95 does not like static_cast here. + // + return (const T*) (data_); + } + + template <typename T> + inline T* pod_seq<T>:: + end () + { + return static_cast<T*> (data_) + size_; + } + + template <typename T> + inline const T* pod_seq<T>:: + end () const + { + return ((const T*) (data_)) + size_; + } + + template <typename T> + inline T& pod_seq<T>:: + front () + { + return *static_cast<T*> (data_); + } + + template <typename T> + inline const T& pod_seq<T>:: + front () const + { + return *((const T*) (data_)); + } + + template <typename T> + inline T& pod_seq<T>:: + back () + { + return static_cast<T*> (data_)[size_ - 1]; + } + + template <typename T> + inline const T& pod_seq<T>:: + back () const + { + return ((const T*) (data_))[size_ - 1]; + } + + template <typename T> + inline T& pod_seq<T>:: + operator[] (size_t i) + { + return static_cast<T*> (data_)[i]; + } + + template <typename T> + inline const T& pod_seq<T>:: + operator[] (size_t i) const + { + return ((const T*) (data_))[i]; + } + + template <typename T> + inline void pod_seq<T>:: + clear () + { + size_ = 0; + } + + template <typename T> + inline void pod_seq<T>:: + pop_back () + { + --size_; + } + + template <typename T> + inline T* pod_seq<T>:: + erase (T* i) + { + if (i != static_cast<T*> (data_) + (size_ - 1)) + erase_ (i, sizeof (T), 0); + else + --size_; + + return i; + } + +#ifdef XSDE_EXCEPTIONS + template <typename T> + inline void pod_seq<T>:: + push_back (const T& x) + { + if (capacity_ < size_ + 1) + grow_ (0, sizeof (T), 0); + + static_cast<T*> (data_)[size_++] = x; + } + + template <typename T> + inline T* pod_seq<T>:: + insert (T* i, const T& x) + { + T* p = static_cast<T*> (insert_ (i, sizeof (T), 0, 0)); + *p = x; + return p; + } + + template <typename T> + inline void pod_seq<T>:: + reserve (size_t n) + { + if (capacity_ < n) + grow_ (n, sizeof (T), 0); + } +#else + template <typename T> + inline sequence_base::error pod_seq<T>:: + push_back (const T& x) + { + error r = error_none; + + if (capacity_ < size_ + 1) + r = grow_ (0, sizeof (T), 0); + + if (r == error_none) + static_cast<T*> (data_)[size_++] = x; + + return r; + } + + template <typename T> + inline sequence_base::error pod_seq<T>:: + insert (T* i, const T& x) + { + T* p = static_cast<T*> (insert_ (i, sizeof (T), 0, 0)); + + if (p) + { + *p = x; + return error_none; + } + else + return error_no_memory; + } + + template <typename T> + inline sequence_base::error pod_seq<T>:: + insert (T* i, const T& x, T*& r) + { + T* p = static_cast<T*> (insert_ (i, sizeof (T), 0, 0)); + + if (p) + { + *p = x; + r = p; + return error_none; + } + else + return error_no_memory; + } + + template <typename T> + inline sequence_base::error pod_seq<T>:: + reserve (size_t n) + { + error r = error_none; + if (capacity_ < n) + r = grow_ (n, sizeof (T), 0); + return r; + } +#endif + + // + // fix_seq + // + + template <typename T> + inline fix_seq<T>:: + ~fix_seq () + { + clear (); + } + + template <typename T> + inline size_t fix_seq<T>:: + max_size () const + { + return size_t (-1) / sizeof (T); + } + + template <typename T> + inline void fix_seq<T>:: + swap (fix_seq& x) + { + swap_ (x); + } + + template <typename T> + inline T* fix_seq<T>:: + begin () + { + return static_cast<T*> (data_); + } + + template <typename T> + inline const T* fix_seq<T>:: + begin () const + { + return (const T*) (data_); + } + + template <typename T> + inline T* fix_seq<T>:: + end () + { + return static_cast<T*> (data_) + size_; + } + + template <typename T> + inline const T* fix_seq<T>:: + end () const + { + return ((const T*) (data_)) + size_; + } + + template <typename T> + inline T& fix_seq<T>:: + front () + { + return *static_cast<T*> (data_); + } + + template <typename T> + inline const T& fix_seq<T>:: + front () const + { + return *((const T*) (data_)); + } + + template <typename T> + inline T& fix_seq<T>:: + back () + { + return static_cast<T*> (data_)[size_ - 1]; + } + + template <typename T> + inline const T& fix_seq<T>:: + back () const + { + return ((const T*) (data_))[size_ - 1]; + } + + template <typename T> + inline T& fix_seq<T>:: + operator[] (size_t i) + { + return static_cast<T*> (data_)[i]; + } + + template <typename T> + inline const T& fix_seq<T>:: + operator[] (size_t i) const + { + return ((const T*) (data_))[i]; + } + + template <typename T> + inline void fix_seq<T>:: + pop_back () + { + static_cast<T*> (data_)[size_ - 1].~T (); + --size_; + } + + template <typename T> + inline T* fix_seq<T>:: + erase (T* i) + { + if (i != static_cast<T*> (data_) + (size_ - 1)) + erase_ (i, sizeof (T), &move_forward_); + else + { + static_cast<T*> (data_)[size_ - 1].~T (); + --size_; + } + + return i; + } + +#ifdef XSDE_EXCEPTIONS + template <typename T> + inline void fix_seq<T>:: + push_back (const T& x) + { + if (capacity_ < size_ + 1) + grow_ (0, sizeof (T), &move_); + + new (static_cast<T*> (data_) + size_) T (x); + size_++; + } + + template <typename T> + inline T* fix_seq<T>:: + insert (T* i, const T& x) + { + T* p = static_cast<T*> ( + insert_ (i, sizeof (T), &move_, &move_backward_)); + *p = x; + return p; + } + + template <typename T> + inline void fix_seq<T>:: + reserve (size_t n) + { + if (capacity_ < n) + grow_ (n, sizeof (T), &move_); + } +#else + template <typename T> + inline sequence_base::error fix_seq<T>:: + push_back (const T& x) + { + error r = error_none; + + if (capacity_ < size_ + 1) + r = grow_ (0, sizeof (T), &move_); + + if (r == error_none) + { + new (static_cast<T*> (data_) + size_) T (x); + size_++; + } + + return r; + } + + template <typename T> + inline sequence_base::error fix_seq<T>:: + insert (T* i, const T& x) + { + T* p = static_cast<T*> ( + insert_ (i, sizeof (T), &move_, &move_backward_)); + + if (p) + { + *p = x; + return error_none; + } + else + return error_no_memory; + } + + template <typename T> + inline sequence_base::error fix_seq<T>:: + insert (T* i, const T& x, T*& r) + { + T* p = static_cast<T*> ( + insert_ (i, sizeof (T), &move_, &move_backward_)); + + if (p) + { + *p = x; + r = p; + return error_none; + } + else + return error_no_memory; + } + + template <typename T> + inline sequence_base::error fix_seq<T>:: + reserve (size_t n) + { + error r = error_none; + if (capacity_ < n) + r = grow_ (n, sizeof (T), &move_); + return r; + } +#endif + + // + // var_seq + // + + template <typename T> + inline var_seq<T>:: + ~var_seq () + { + clear (); + } + + template <typename T> + inline size_t var_seq<T>:: + max_size () const + { + return size_t (-1) / sizeof (T*); + } + + template <typename T> + inline void var_seq<T>:: + swap (var_seq& x) + { + swap_ (x); + } + + template <typename T> + inline var_iterator<T> var_seq<T>:: + begin () + { + return iterator (static_cast<T**> (data_)); + } + + template <typename T> + inline var_const_iterator<T> var_seq<T>:: + begin () const + { + return const_iterator ((const T**) (data_)); + } + + template <typename T> + inline var_iterator<T> var_seq<T>:: + end () + { + return iterator (static_cast<T**> (data_) + size_); + } + + template <typename T> + inline var_const_iterator<T> var_seq<T>:: + end () const + { + return const_iterator (((const T**) (data_)) + size_); + } + + template <typename T> + inline T& var_seq<T>:: + front () + { + return **static_cast<T**> (data_); + } + + template <typename T> + inline const T& var_seq<T>:: + front () const + { + // g++ 2.95 does not like static_cast here. + // + return **((const T* const*) (data_)); + } + + template <typename T> + inline T& var_seq<T>:: + back () + { + return *(static_cast<T**> (data_)[size_ - 1]); + } + + template <typename T> + inline const T& var_seq<T>:: + back () const + { + return *(((const T* const*) (data_))[size_ - 1]); + } + + template <typename T> + inline T& var_seq<T>:: + operator[] (size_t i) + { + return *(static_cast<T**> (data_)[i]); + } + + template <typename T> + inline const T& var_seq<T>:: + operator[] (size_t i) const + { + return *(((const T* const*) (data_))[i]); + } + + template <typename T> + inline void var_seq<T>:: + pop_back () + { + delete static_cast<T**> (data_)[size_ - 1]; + --size_; + } + + template <typename T> + inline var_iterator<T> var_seq<T>:: + erase (iterator i) + { + delete *i.i_; + + if (i.i_ != static_cast<T**> (data_) + (size_ - 1)) + erase_ (i.i_, sizeof (T*), 0); + else + --size_; + + return i; + } + +#ifdef XSDE_EXCEPTIONS + template <typename T> + inline void var_seq<T>:: + push_back (T* x) + { + guard g (x); + + if (capacity_ < size_ + 1) + grow_ (0, sizeof (T*), 0); + + static_cast<T**> (data_)[size_++] = x; + + g.release (); + } + + template <typename T> + inline var_iterator<T> var_seq<T>:: + insert (iterator i, T* x) + { + guard g (x); + T** p = static_cast<T**> (insert_ (i.i_, sizeof (T*), 0, 0)); + *p = x; + g.release (); + return iterator (p); + } + + template <typename T> + inline void var_seq<T>:: + reserve (size_t n) + { + if (capacity_ < n) + grow_ (n, sizeof (T*), 0); + } +#else + template <typename T> + inline sequence_base::error var_seq<T>:: + push_back (T* x) + { + error r = error_none; + + if (capacity_ < size_ + 1) + r = grow_ (0, sizeof (T*), 0); + + if (r == error_none) + static_cast<T**> (data_)[size_++] = x; + else + delete x; + + return r; + } + + template <typename T> + inline sequence_base::error var_seq<T>:: + insert (iterator i, T* x) + { + T** p = static_cast<T**> (insert_ (i.i_, sizeof (T*), 0, 0)); + + if (p) + { + *p = x; + return error_none; + } + else + { + delete x; + return error_no_memory; + } + } + + template <typename T> + inline sequence_base::error var_seq<T>:: + insert (iterator i, T* x, iterator& r) + { + T** p = static_cast<T**> (insert_ (i.i_, sizeof (T*), 0, 0)); + + if (p) + { + *p = x; + r.i_ = p; + return error_none; + } + else + { + delete x; + return error_no_memory; + } + } + + template <typename T> + inline sequence_base::error var_seq<T>:: + reserve (size_t n) + { + error r = error_none; + if (capacity_ < n) + r = grow_ (n, sizeof (T*), 0); + return r; + } +#endif + + // + // data_seq + // + + inline data_seq:: + ~data_seq () + { + clear (); + } + + inline data_seq:: + data_seq () + : destructor_ (0) + { + } + + inline void data_seq:: + destructor (data_seq::destroy_func d) + { + destructor_ = d; + } + + inline size_t data_seq:: + max_size () const + { + return size_t (-1) / sizeof (void*); + } + + inline void data_seq:: + swap (data_seq& x) + { + swap_ (x); + } + + inline data_seq::iterator data_seq:: + begin () + { + return static_cast<void**> (data_); + } + + inline data_seq::const_iterator data_seq:: + begin () const + { + // g++ 2.95 does not like static_cast here. + // + return (const void* const*) (data_); + } + + inline data_seq::iterator data_seq:: + end () + { + return static_cast<void**> (data_) + size_; + } + + inline data_seq::const_iterator data_seq:: + end () const + { + return ((const void* const*) (data_)) + size_; + } + + inline void* data_seq:: + front () + { + return *static_cast<void**> (data_); + } + + inline const void* data_seq:: + front () const + { + return *((const void* const*) (data_)); + } + + inline void* data_seq:: + back () + { + return static_cast<void**> (data_)[size_ - 1]; + } + + inline const void* data_seq:: + back () const + { + return ((const void* const*) (data_))[size_ - 1]; + } + + inline void* data_seq:: + operator[] (size_t i) + { + return static_cast<void**> (data_)[i]; + } + + inline const void* data_seq:: + operator[] (size_t i) const + { + return ((const void* const*) (data_))[i]; + } + + inline void data_seq:: + pop_back () + { + if (destructor_) + destructor_ (static_cast<void**> (data_)[size_ - 1], size_ - 1); + --size_; + } + + inline data_seq::iterator data_seq:: + erase (iterator i) + { + if (destructor_) + destructor_ (*i, i - static_cast<void**> (data_)); + + if (i != static_cast<void**> (data_) + (size_ - 1)) + erase_ (i, sizeof (void*), 0); + else + --size_; + + return i; + } + +#ifdef XSDE_EXCEPTIONS + namespace data_seq_bits + { + struct guard + { + ~guard () { if (p_ && d_) d_ (p_, i_); } + guard (data_seq::destroy_func d, void* p, size_t i) + : d_ (d), p_ (p), i_ (i) {} + + void + release () { p_ = 0; } + + private: + data_seq::destroy_func d_; + void* p_; + size_t i_; + }; + } + + inline void data_seq:: + push_back (void* x) + { + data_seq_bits::guard g (destructor_, x, size_); + + if (capacity_ < size_ + 1) + grow_ (0, sizeof (void*), 0); + + static_cast<void**> (data_)[size_++] = x; + + g.release (); + } + + inline data_seq::iterator data_seq:: + insert (iterator i, void* x) + { + data_seq_bits::guard g ( + destructor_, x, i - static_cast<void**> (data_)); + + void** p = static_cast<void**> (insert_ (i, sizeof (void*), 0, 0)); + *p = x; + g.release (); + return p; + } + + inline void data_seq:: + reserve (size_t n) + { + if (capacity_ < n) + grow_ (n, sizeof (void*), 0); + } +#else + inline sequence_base::error data_seq:: + push_back (void* x) + { + error r = error_none; + + if (capacity_ < size_ + 1) + r = grow_ (0, sizeof (void*), 0); + + if (r == error_none) + static_cast<void**> (data_)[size_++] = x; + else + { + if (destructor_) + destructor_ (x, size_); + } + + return r; + } + + inline sequence_base::error data_seq:: + insert (iterator i, void* x) + { + size_t pos = i - static_cast<void**> (data_); + void** p = static_cast<void**> (insert_ (i, sizeof (void*), 0, 0)); + + if (p) + { + *p = x; + return error_none; + } + else + { + if (destructor_) + destructor_ (x, pos); + return error_no_memory; + } + } + + inline sequence_base::error data_seq:: + insert (iterator i, void* x, iterator& r) + { + size_t pos = i - static_cast<void**> (data_); + void** p = static_cast<void**> (insert_ (i, sizeof (void*), 0, 0)); + + if (p) + { + *p = x; + r = p; + return error_none; + } + else + { + if (destructor_) + destructor_ (x, pos); + return error_no_memory; + } + } + + inline sequence_base::error data_seq:: + reserve (size_t n) + { + error r = error_none; + if (capacity_ < n) + r = grow_ (n, sizeof (void*), 0); + return r; + } +#endif + } + } +} |