aboutsummaryrefslogtreecommitdiff
path: root/libxsd/xsd/cxx/tree/buffer.txx
diff options
context:
space:
mode:
Diffstat (limited to 'libxsd/xsd/cxx/tree/buffer.txx')
-rw-r--r--libxsd/xsd/cxx/tree/buffer.txx153
1 files changed, 153 insertions, 0 deletions
diff --git a/libxsd/xsd/cxx/tree/buffer.txx b/libxsd/xsd/cxx/tree/buffer.txx
new file mode 100644
index 0000000..6212e20
--- /dev/null
+++ b/libxsd/xsd/cxx/tree/buffer.txx
@@ -0,0 +1,153 @@
+// file : xsd/cxx/tree/buffer.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
+
+namespace xsd
+{
+ namespace cxx
+ {
+ namespace tree
+ {
+ template <typename C>
+ buffer<C>::
+ buffer (size_t size)
+ {
+ capacity (size);
+ size_ = size;
+ }
+
+ template <typename C>
+ buffer<C>::
+ buffer (size_t size, size_t capacity)
+ {
+ if (size > capacity)
+ throw bounds<C> ();
+
+ this->capacity (capacity);
+ size_ = size;
+ }
+
+ template <typename C>
+ buffer<C>::
+ buffer (const void* data, size_t size)
+ {
+ capacity (size);
+ size_ = size;
+
+ if (size_)
+ std::memcpy (data_, data, size_);
+ }
+
+ template <typename C>
+ buffer<C>::
+ buffer (const void* data, size_t size, size_t capacity)
+ {
+ if (size > capacity)
+ throw bounds<C> ();
+
+ this->capacity (capacity);
+ size_ = size;
+
+ if (size_)
+ std::memcpy (data_, data, size_);
+ }
+
+ template <typename C>
+ buffer<C>::
+ buffer (void* data, size_t size, size_t capacity, bool own)
+ {
+ if (size > capacity)
+ throw bounds<C> ();
+
+ if (own)
+ {
+ data_ = reinterpret_cast<char*> (data);
+ size_ = size;
+ capacity_ = capacity;
+ }
+ else
+ {
+ this->capacity (capacity);
+ size_ = size;
+
+ if (size_)
+ std::memcpy (data_, data, size_);
+ }
+ }
+
+ template <typename C>
+ buffer<C>::
+ buffer (const buffer& other)
+ : buffer_base ()
+ {
+ capacity (other.capacity_);
+ size_ = other.size_;
+
+ if (size_)
+ std::memcpy (data_, other.data_, size_);
+ }
+
+ template <typename C>
+ buffer<C>& buffer<C>::
+ operator= (const buffer& other)
+ {
+ if (this != &other)
+ {
+ capacity (other.capacity_, false);
+ size_ = other.size_;
+
+ if (size_)
+ std::memcpy (data_, other.data_, size_);
+ }
+
+ return *this;
+ }
+
+ template <typename C>
+ void buffer<C>::
+ swap (buffer& other)
+ {
+ char* tmp_data (data_);
+ size_t tmp_size (size_);
+ size_t tmp_capacity (capacity_);
+
+ data_ = other.data_;
+ size_ = other.size_;
+ capacity_ = other.capacity_;
+
+ other.data_ = tmp_data;
+ other.size_ = tmp_size;
+ other.capacity_ = tmp_capacity;
+ }
+
+ template <typename C>
+ bool buffer<C>::
+ capacity (size_t capacity, bool copy)
+ {
+ if (size_ > capacity)
+ throw bounds<C> ();
+
+ if (capacity <= capacity_)
+ {
+ return false; // Do nothing if shrinking is requested.
+ }
+ else
+ {
+ char* data (reinterpret_cast<char*> (operator new (capacity)));
+
+ if (copy && size_ > 0)
+ std::memcpy (data, data_, size_);
+
+ if (data_)
+ operator delete (data_);
+
+ data_ = data;
+ capacity_ = capacity;
+
+ return true;
+ }
+ }
+ }
+ }
+}