diff options
Diffstat (limited to 'libxsde/xsde/cxx/hybrid')
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/any-type.hxx | 26 | ||||
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/base.hxx | 370 | ||||
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/sequence.cxx | 31 | ||||
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/sequence.hxx | 921 | ||||
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/sequence.ixx | 881 | ||||
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/sequence.txx | 133 | ||||
| -rw-r--r-- | libxsde/xsde/cxx/hybrid/xml-schema.hxx | 23 |
7 files changed, 2385 insertions, 0 deletions
diff --git a/libxsde/xsde/cxx/hybrid/any-type.hxx b/libxsde/xsde/cxx/hybrid/any-type.hxx new file mode 100644 index 0000000..db512c2 --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/any-type.hxx @@ -0,0 +1,26 @@ +// file : xsde/cxx/hybrid/any-type.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSDE_CXX_HYBRID_ANY_TYPE_HXX +#define XSDE_CXX_HYBRID_ANY_TYPE_HXX + +namespace xsde +{ + namespace cxx + { + namespace hybrid + { + struct any_type + { + }; + + struct any_simple_type + { + }; + } + } +} + +#endif // XSDE_CXX_HYBRID_ANY_TYPE_HXX diff --git a/libxsde/xsde/cxx/hybrid/base.hxx b/libxsde/xsde/cxx/hybrid/base.hxx new file mode 100644 index 0000000..75753bc --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/base.hxx @@ -0,0 +1,370 @@ +// file : xsde/cxx/hybrid/base.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSDE_CXX_HYBRID_BASE_HXX +#define XSDE_CXX_HYBRID_BASE_HXX + +#include <xsde/cxx/config.hxx> + +namespace xsde +{ + namespace cxx + { + namespace hybrid + { + // boolean + // + struct boolean_base + { + bool base_value () const {return x_;} + bool& base_value () {return x_;} + void base_value (bool x) {x_ = x;} + + operator const bool& () const {return x_;} + operator bool& () {return x_;} + + boolean_base& operator= (bool x) {x_ = x; return *this;} + + protected: + bool x_; + }; + + // byte + // + struct byte_base + { + signed char base_value () const {return x_;} + signed char& base_value () {return x_;} + void base_value (signed char x) {x_ = x;} + + operator const signed char& () const {return x_;} + operator signed char& () {return x_;} + + byte_base& operator= (signed char x) {x_ = x; return *this;} + + protected: + signed char x_; + }; + + // unsigned_byte + // + struct unsigned_byte_base + { + unsigned char base_value () const {return x_;} + unsigned char& base_value () {return x_;} + void base_value (unsigned char x) {x_ = x;} + + operator const unsigned char& () const {return x_;} + operator unsigned char& () {return x_;} + + unsigned_byte_base& + operator= (unsigned char x) {x_ = x; return *this;} + + protected: + unsigned char x_; + }; + + // short + // + struct short_base + { + short base_value () const {return x_;} + short& base_value () {return x_;} + void base_value (short x) {x_ = x;} + + operator const short& () const {return x_;} + operator short& () {return x_;} + + short_base& operator= (short x) {x_ = x; return *this;} + + protected: + short x_; + }; + + // unsigned_short + // + struct unsigned_short_base + { + unsigned short base_value () const {return x_;} + unsigned short& base_value () {return x_;} + void base_value (unsigned short x) {x_ = x;} + + operator const unsigned short& () const {return x_;} + operator unsigned short& () {return x_;} + + unsigned_short_base& + operator= (unsigned short x) {x_ = x; return *this;} + + protected: + unsigned short x_; + }; + + // int + // + struct int_base + { + int base_value () const {return x_;} + int& base_value () {return x_;} + void base_value (int x) {x_ = x;} + + operator const int& () const {return x_;} + operator int& () {return x_;} + + int_base& operator= (int x) {x_ = x; return *this;} + + protected: + int x_; + }; + + // unsigned_int + // + struct unsigned_int_base + { + unsigned int base_value () const {return x_;} + unsigned int& base_value () {return x_;} + void base_value (unsigned int x) {x_ = x;} + + operator const unsigned int& () const {return x_;} + operator unsigned int& () {return x_;} + + unsigned_int_base& operator= (unsigned int x) {x_ = x; return *this;} + + protected: + unsigned int x_; + }; + + // long + // +#ifdef XSDE_LONGLONG + struct long_base + { + long long base_value () const {return x_;} + long long& base_value () {return x_;} + void base_value (long long x) {x_ = x;} + + operator const long long& () const {return x_;} + operator long long& () {return x_;} + + long_base& operator= (long long x) {x_ = x; return *this;} + + protected: + long long x_; + }; +#else + struct long_base + { + long base_value () const {return x_;} + long& base_value () {return x_;} + void base_value (long x) {x_ = x;} + + operator const long& () const {return x_;} + operator long& () {return x_;} + + long_base& operator= (long x) {x_ = x; return *this;} + + protected: + long x_; + }; +#endif + + + // unsigned_long + // +#ifdef XSDE_LONGLONG + struct unsigned_long_base + { + unsigned long long base_value () const {return x_;} + unsigned long long& base_value () {return x_;} + void base_value (unsigned long long x) {x_ = x;} + + operator const unsigned long long& () const {return x_;} + operator unsigned long long& () {return x_;} + + unsigned_long_base& + operator= (unsigned long long x) {x_ = x; return *this;} + + protected: + unsigned long long x_; + }; +#else + struct unsigned_long_base + { + unsigned long base_value () const {return x_;} + unsigned long& base_value () {return x_;} + void base_value (unsigned long x) {x_ = x;} + + operator const unsigned long& () const {return x_;} + operator unsigned long& () {return x_;} + + unsigned_long_base& + operator= (unsigned long x) {x_ = x; return *this;} + + protected: + unsigned long x_; + }; +#endif + + // integer + // + struct integer_base + { + long base_value () const {return x_;} + long& base_value () {return x_;} + void base_value (long x) {x_ = x;} + + operator const long& () const {return x_;} + operator long& () {return x_;} + + integer_base& operator= (long x) {x_ = x; return *this;} + + protected: + long x_; + }; + + // negative_integer + // + struct negative_integer_base + { + long base_value () const {return x_;} + long& base_value () {return x_;} + void base_value (long x) {x_ = x;} + + operator const long& () const {return x_;} + operator long& () {return x_;} + + negative_integer_base& operator= (long x) {x_ = x; return *this;} + + protected: + long x_; + }; + + // non_positive_integer + // + struct non_positive_integer_base + { + long base_value () const {return x_;} + long& base_value () {return x_;} + void base_value (long x) {x_ = x;} + + operator const long& () const {return x_;} + operator long& () {return x_;} + + non_positive_integer_base& operator= (long x) {x_ = x; return *this;} + + protected: + long x_; + }; + + // positive_integer + // + struct positive_integer_base + { + unsigned long base_value () const {return x_;} + unsigned long& base_value () {return x_;} + void base_value (unsigned long x) {x_ = x;} + + operator const unsigned long& () const {return x_;} + operator unsigned long& () {return x_;} + + positive_integer_base& + operator= (unsigned long x) {x_ = x; return *this;} + + protected: + unsigned long x_; + }; + + // non_negative_integer + // + struct non_negative_integer_base + { + unsigned long base_value () const {return x_;} + unsigned long& base_value () {return x_;} + void base_value (unsigned long x) {x_ = x;} + + operator const unsigned long& () const {return x_;} + operator unsigned long& () {return x_;} + + non_negative_integer_base& + operator= (unsigned long x) {x_ = x; return *this;} + + protected: + unsigned long x_; + }; + + // float + // + struct float_base + { + float base_value () const {return x_;} + float& base_value () {return x_;} + void base_value (float x) {x_ = x;} + + operator const float& () const {return x_;} + operator float& () {return x_;} + + float_base& operator= (float x) {x_ = x; return *this;} + + protected: + float x_; + }; + + // double + // + struct double_base + { + double base_value () const {return x_;} + double& base_value () {return x_;} + void base_value (double x) {x_ = x;} + + operator const double& () const {return x_;} + operator double& () {return x_;} + + double_base& operator= (double x) {x_ = x; return *this;} + + protected: + double x_; + }; + + // decimal + // + struct decimal_base + { + double base_value () const {return x_;} + double& base_value () {return x_;} + void base_value (double x) {x_ = x;} + + operator const double& () const {return x_;} + operator double& () {return x_;} + + decimal_base& operator= (double x) {x_ = x; return *this;} + + protected: + double x_; + }; + + // string + // + struct string_base + { + string_base () : x_ (0) {} + ~string_base () {delete[] x_;} + + const char* base_value () const {return x_;} + char* base_value () {return x_;} + void base_value (char* x) {delete[] x_; x_ = x;} + + operator const char* () const {return x_;} + operator char* () {return x_;} + + string_base& operator= (char* x) {delete[] x_; x_ = x; return *this;} + + protected: + char* x_; + }; + } + } +} + +#endif // XSDE_CXX_HYBRID_BASE_HXX diff --git a/libxsde/xsde/cxx/hybrid/sequence.cxx b/libxsde/xsde/cxx/hybrid/sequence.cxx new file mode 100644 index 0000000..da16e95 --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/sequence.cxx @@ -0,0 +1,31 @@ +// file : xsde/cxx/hybrid/sequence.cxx +// 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 <xsde/cxx/hybrid/sequence.hxx> + +namespace xsde +{ + namespace cxx + { + namespace hybrid + { + // + // data_seq + // + + void data_seq:: + clear () + { + if (destructor_) + { + for (size_t i = 0; i < size_; ++i) + destructor_ (static_cast<void**> (data_)[i], i); + } + + size_ = 0; + } + } + } +} diff --git a/libxsde/xsde/cxx/hybrid/sequence.hxx b/libxsde/xsde/cxx/hybrid/sequence.hxx new file mode 100644 index 0000000..d7f6dcb --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/sequence.hxx @@ -0,0 +1,921 @@ +// file : xsde/cxx/hybrid/sequence.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSDE_CXX_HYBRID_SEQUENCE_HXX +#define XSDE_CXX_HYBRID_SEQUENCE_HXX + +#include <stddef.h> // size_t, ptrdiff_t + +#include <xsde/cxx/config.hxx> +#include <xsde/cxx/sequence-base.hxx> + +#ifdef XSDE_STL +# include <xsde/cxx/string-sequence-stl.hxx> +#else +# include <xsde/cxx/string-sequence.hxx> +#endif + +namespace xsde +{ + namespace cxx + { + namespace hybrid + { + // Sequence with fixed-length POD elements. + // + template <typename T> + class pod_seq: public sequence_base + { + public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + typedef T* iterator; + typedef const T* const_iterator; + + public: + iterator + begin (); + + const_iterator + begin () const; + + iterator + end (); + + const_iterator + end () const; + + T& + front (); + + const T& + front () const; + + T& + back (); + + const T& + back () const; + + T& + operator[] (size_t); + + const T& + operator[] (size_t) const; + + public: + size_t + max_size () const; + + void + clear (); + + void + pop_back (); + + iterator + erase (iterator); + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + push_back (const T&); + +#ifndef XSDE_EXCEPTIONS + error + insert (iterator, const T&); + + error + insert (iterator, const T&, iterator& result); +#else + iterator + insert (iterator, const T&); +#endif + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + reserve (size_t); + + void + swap (pod_seq&); + }; + + // Sequence with fixed-length elements. + // + template <typename T> + class fix_seq: public sequence_base + { + public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + typedef T* iterator; + typedef const T* const_iterator; + + public: + ~fix_seq (); + + public: + iterator + begin (); + + const_iterator + begin () const; + + iterator + end (); + + const_iterator + end () const; + + T& + front (); + + const T& + front () const; + + T& + back (); + + const T& + back () const; + + T& + operator[] (size_t); + + const T& + operator[] (size_t) const; + + public: + size_t + max_size () const; + + void + clear (); + + void + pop_back (); + + iterator + erase (iterator); + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + push_back (const T&); + +#ifndef XSDE_EXCEPTIONS + error + insert (iterator, const T&); + + error + insert (iterator, const T&, iterator& result); +#else + iterator + insert (iterator, const T&); +#endif + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + reserve (size_t); + + void + swap (fix_seq&); + + private: + static void + move_ (void* dst, void* src, size_t n); + + static void + move_forward_ (void* p, size_t n); + +#ifdef XSDE_EXCEPTIONS + static void + move_backward_ (void* p, size_t n, size_t& size); +#else + static void + move_backward_ (void* p, size_t n); +#endif + +#ifdef XSDE_EXCEPTIONS + struct guard + { + guard (T* p, size_t& n) : p_ (p), n_ (n) {} + + ~guard () + { + if (p_) + for (; n_ > 0; --n_) + p_[n_ - 1].~T (); + } + + void + release () { p_ = 0; } + + private: + T* p_; + size_t& n_; + }; +#endif + }; + + // Sequence with variable-length elements. + // + template <typename T> + class var_iterator + { + public: + typedef T value_type; + typedef T& reference; + typedef T* pointer; + + typedef ptrdiff_t difference_type; + + public: + var_iterator () + : i_ (0) + { + } + + explicit + var_iterator (T** i) + : i_ (i) + { + } + + public: + // Forward iterator requirements. + // + T& + operator* () const + { + return **i_; + } + + T* + operator-> () const + { + return *i_; + } + + var_iterator& + operator++ () + { + ++i_; + return *this; + } + + var_iterator + operator++ (int) + { + var_iterator r (*this); + ++i_; + return r; + } + + // Bidirectional iterator requirements. + // + var_iterator& + operator-- () + { + --i_; + return *this; + } + + var_iterator + operator-- (int) + { + var_iterator r (*this); + --i_; + return r; + } + + // Random access iterator requirements. + // + T& + operator[] (ptrdiff_t n) const + { + return *(i_[n]); + } + + var_iterator& + operator+= (ptrdiff_t n) + { + i_ += n; + return *this; + } + + var_iterator + operator+ (ptrdiff_t n) const + { + return var_iterator (i_ + n); + } + + var_iterator& + operator-= (ptrdiff_t n) + { + i_ -= n; + return *this; + } + + var_iterator + operator- (ptrdiff_t n) const + { + return var_iterator (i_ - n); + } + + public: + T** i_; + }; + + template <typename T> + class var_const_iterator + { + public: + typedef const T value_type; + typedef const T& reference; + typedef const T* pointer; + + typedef ptrdiff_t difference_type; + + public: + var_const_iterator () + : i_ (0) + { + } + + var_const_iterator (var_iterator<T> j) + : i_ (const_cast<const T**> (j.i_)) + { + } + + explicit + var_const_iterator (const T** i) + : i_ (i) + { + } + + var_const_iterator& + operator= (var_const_iterator j) + { + i_ = j.i_; + return *this; + } + + var_const_iterator& + operator= (var_iterator<T> j) + { + i_ = const_cast<const T**> (j.i_); + return *this; + } + + public: + // Forward iterator requirements. + // + const T& + operator* () const + { + return **i_; + } + + const T* + operator-> () const + { + return *i_; + } + + var_const_iterator& + operator++ () + { + ++i_; + return *this; + } + + var_const_iterator + operator++ (int) + { + var_const_iterator r (*this); + ++i_; + return r; + } + + // Bidirectional iterator requirements. + // + var_const_iterator& + operator-- () + { + --i_; + return *this; + } + + var_const_iterator + operator-- (int) + { + var_const_iterator r (*this); + --i_; + return r; + } + + // Random access iterator requirements. + // + const T& + operator[] (ptrdiff_t n) const + { + return *(i_[n]); + } + + var_const_iterator& + operator+= (ptrdiff_t n) + { + i_ += n; + return *this; + } + + var_const_iterator + operator+ (ptrdiff_t n) const + { + return var_const_iterator (i_ + n); + } + + var_const_iterator& + operator-= (ptrdiff_t n) + { + i_ -= n; + return *this; + } + + var_const_iterator + operator- (ptrdiff_t n) const + { + return var_const_iterator (i_ - n); + } + + public: + const T** i_; + }; + + // Forward iterator requirements. + // + template <typename T> + inline bool + operator== (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ == j.i_; + } + + template <typename T> + inline bool + operator== (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ == j.i_; + } + + template <typename T> + inline bool + operator== (var_iterator<T> i, var_const_iterator<T> j) + { + // eVC++ 4.0 needs the cast. + // + return const_cast<const T**> (i.i_) == j.i_; + } + + template <typename T> + inline bool + operator== (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ == const_cast<const T**> (j.i_); + } + + template <typename T> + inline bool + operator!= (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ != j.i_; + } + + template <typename T> + inline bool + operator!= (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ != j.i_; + } + + template <typename T> + inline bool + operator!= (var_iterator<T> i, var_const_iterator<T> j) + { + return const_cast<const T**> (i.i_) != j.i_; + } + + template <typename T> + inline bool + operator!= (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ != const_cast<const T**> (j.i_); + } + + // Random access iterator requirements + // + template <typename T> + inline bool + operator< (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ < j.i_; + } + + template <typename T> + inline bool + operator< (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ < j.i_; + } + + template <typename T> + inline bool + operator< (var_iterator<T> i, var_const_iterator<T> j) + { + return const_cast<const T**> (i.i_) < j.i_; + } + + template <typename T> + inline bool + operator< (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ < const_cast<const T**> (j.i_); + } + + template <typename T> + inline bool + operator> (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ > j.i_; + } + + template <typename T> + inline bool + operator> (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ > j.i_; + } + + template <typename T> + inline bool + operator> (var_iterator<T> i, var_const_iterator<T> j) + { + return const_cast<const T**> (i.i_) > j.i_; + } + + template <typename T> + inline bool + operator> (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ > const_cast<const T**> (j.i_); + } + + template <typename T> + inline bool + operator<= (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ <= j.i_; + } + + template <typename T> + inline bool + operator<= (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ <= j.i_; + } + + template <typename T> + inline bool + operator<= (var_iterator<T> i, var_const_iterator<T> j) + { + return const_cast<const T**> (i.i_) <= j.i_; + } + + template <typename T> + inline bool + operator<= (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ <= const_cast<const T**> (j.i_); + } + + template <typename T> + inline bool + operator>= (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ >= j.i_; + } + + template <typename T> + inline bool + operator>= (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ >= j.i_; + } + + template <typename T> + inline bool + operator>= (var_iterator<T> i, var_const_iterator<T> j) + { + return const_cast<const T**> (i.i_) >= j.i_; + } + + template <typename T> + inline bool + operator>= (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ >= const_cast<const T**> (j.i_); + } + + template <typename T> + inline ptrdiff_t + operator- (var_iterator<T> i, var_iterator<T> j) + { + return i.i_ - j.i_; + } + + template <typename T> + inline ptrdiff_t + operator- (var_const_iterator<T> i, var_const_iterator<T> j) + { + return i.i_ - j.i_; + } + + template <typename T> + inline ptrdiff_t + operator- (var_iterator<T> i, var_const_iterator<T> j) + { + return const_cast<const T**> (i.i_) - j.i_; + } + + template <typename T> + inline ptrdiff_t + operator- (var_const_iterator<T> i, var_iterator<T> j) + { + return i.i_ - const_cast<const T**> (j.i_); + } + + template <typename T> + inline var_iterator<T> + operator+ (ptrdiff_t n, var_iterator<T> i) + { + return var_iterator<T> (i.i_ + n); + } + + template <typename T> + inline var_iterator<T> + operator+ (ptrdiff_t n, var_const_iterator<T> i) + { + return var_const_iterator<T> (i.i_ + n); + } + + // + // + template <typename T> + class var_seq: public sequence_base + { + public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + typedef var_iterator<T> iterator; + typedef var_const_iterator<T> const_iterator; + + public: + ~var_seq (); + + public: + iterator + begin (); + + const_iterator + begin () const; + + iterator + end (); + + const_iterator + end () const; + + T& + front (); + + const T& + front () const; + + T& + back (); + + const T& + back () const; + + T& + operator[] (size_t); + + const T& + operator[] (size_t) const; + + public: + size_t + max_size () const; + + void + clear (); + + void + pop_back (); + + iterator + erase (iterator); + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + push_back (T*); + +#ifndef XSDE_EXCEPTIONS + error + insert (iterator, T*); + + error + insert (iterator, T*, iterator& result); +#else + iterator + insert (iterator, T*); +#endif + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + reserve (size_t); + + void + swap (var_seq&); + +#ifdef XSDE_EXCEPTIONS + private: + struct guard + { + ~guard () { delete p_; } + guard (T* p) : p_ (p) {} + + void + release () { p_ = 0; } + + private: + T* p_; + }; +#endif + }; + + + // String sequence. + // + typedef string_sequence str_seq; + + + // Custom data sequence. + // + class data_seq: public sequence_base + { + public: + typedef void* value_type; + typedef void** pointer; + typedef const void** const_pointer; + typedef void* reference; + typedef const void* const_reference; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + typedef void** iterator; + typedef const void* const* const_iterator; + + public: + ~data_seq (); + data_seq (); + + typedef void (*destroy_func) (void* data, size_t pos); + + void + destructor (destroy_func); + + public: + iterator + begin (); + + const_iterator + begin () const; + + iterator + end (); + + const_iterator + end () const; + + void* + front (); + + const void* + front () const; + + void* + back (); + + const void* + back () const; + + void* + operator[] (size_t); + + const void* + operator[] (size_t) const; + + public: + size_t + max_size () const; + + void + clear (); + + void + pop_back (); + + iterator + erase (iterator); + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + push_back (void*); + +#ifndef XSDE_EXCEPTIONS + error + insert (iterator, void*); + + error + insert (iterator, void*, iterator& result); +#else + iterator + insert (iterator, void*); +#endif + +#ifndef XSDE_EXCEPTIONS + error +#else + void +#endif + reserve (size_t); + + void + swap (data_seq&); + + private: + destroy_func destructor_; + }; + } + } +} + +#include <xsde/cxx/hybrid/sequence.ixx> +#include <xsde/cxx/hybrid/sequence.txx> + +#endif // XSDE_CXX_HYBRID_SEQUENCE_HXX 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 + } + } +} diff --git a/libxsde/xsde/cxx/hybrid/sequence.txx b/libxsde/xsde/cxx/hybrid/sequence.txx new file mode 100644 index 0000000..12faa99 --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/sequence.txx @@ -0,0 +1,133 @@ +// file : xsde/cxx/hybrid/sequence.txx +// 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 + { + // + // fix_seq + // + + template <typename T> + void fix_seq<T>:: + clear () + { + for (size_t i = 0; i < size_; ++i) + static_cast<T*> (data_)[i].~T (); + + size_ = 0; + } + +#ifdef XSDE_EXCEPTIONS + template <typename T> + void fix_seq<T>:: + move_ (void* dst, void* src, size_t n) + { + T* d = static_cast<T*> (dst); + T* s = static_cast<T*> (src); + + // The copy c-tor can throw in which case we need to destroy + // whatever objects we already copied into d. + // + size_t i = 0; + guard g (d, i); + + for (; i < n; i++) + new (d + i) T (s[i]); + + g.release (); + + for (size_t j = 0; j < n; j++) + s[j].~T (); + } +#else + template <typename T> + void fix_seq<T>:: + move_ (void* dst, void* src, size_t n) + { + T* d = static_cast<T*> (dst); + T* s = static_cast<T*> (src); + + for (size_t i = 0; i < n; i++) + { + new (d + i) T (s[i]); + s[i].~T (); + } + } +#endif + + template <typename T> + void fix_seq<T>:: + move_forward_ (void* p, size_t n) + { + // We are moving a sequence of elements one position to the left. + // The tricky part is to make sure we are in at least destructable + // state if things turn bad. We assume that there is a valid + // element at position p. + // + T* d = static_cast<T*> (p); + + for (size_t i = 0; i < n; i++) + d[i] = d[i + 1]; + + d[n].~T (); + } + +#ifdef XSDE_EXCEPTIONS + template <typename T> + void fix_seq<T>:: + move_backward_ (void* p, size_t n, size_t& size) + { + // We are moving a sequence of elements one position to the right. + // The tricky part is to make sure we are in at least destructable + // state if things turn bad. + // + T* d = static_cast<T*> (p); + T* e = d + n; + + new (e) T; + size++; + + for (size_t i = n; i > 0; i--) + d[i] = d[i - 1]; + } +#else + template <typename T> + void fix_seq<T>:: + move_backward_ (void* p, size_t n) + { + // We are moving a sequence of elements one position to the right. + // + T* d = static_cast<T*> (p); + T* e = d + n; + + new (e) T; + + for (size_t i = n; i > 0; i--) + d[i] = d[i - 1]; + } +#endif + + // + // var_seq + // + + template <typename T> + void var_seq<T>:: + clear () + { + for (size_t i = 0; i < size_; ++i) + delete static_cast<T**> (data_)[i]; + + size_ = 0; + } + } + } +} diff --git a/libxsde/xsde/cxx/hybrid/xml-schema.hxx b/libxsde/xsde/cxx/hybrid/xml-schema.hxx new file mode 100644 index 0000000..d4b7cdb --- /dev/null +++ b/libxsde/xsde/cxx/hybrid/xml-schema.hxx @@ -0,0 +1,23 @@ +// file : xsde/cxx/hybrid/xml-schema.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSDE_CXX_HYBRID_XML_SCHEMA_HXX +#define XSDE_CXX_HYBRID_XML_SCHEMA_HXX + +#include <xsde/cxx/buffer.hxx> +#include <xsde/cxx/date-time.hxx> + +#ifdef XSDE_STL +# include <xsde/cxx/qname-stl.hxx> +# include <xsde/cxx/string-sequence-stl.hxx> +#else +# include <xsde/cxx/qname.hxx> +# include <xsde/cxx/string-sequence.hxx> +#endif + +#include <xsde/cxx/hybrid/base.hxx> +#include <xsde/cxx/hybrid/any-type.hxx> + +#endif // XSDE_CXX_HYBRID_XML_SCHEMA_HXX |