buffer.hxx

Go to the documentation of this file.

// file      : xsd/cxx/tree/buffer.hxx
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
#ifndef XSD_CXX_TREE_BUFFER_HXX
#define XSD_CXX_TREE_BUFFER_HXX
 
#include <new>     // operator new/delete
#include <cstddef> // std::size_t
#include <cstring> // std::memcpy, std::memcmp
 
#include <xsd/cxx/tree/exceptions.hxx>
 
namespace xsd
{
  namespace cxx
  {
    namespace tree
    {
      //@cond
 
      class buffer_base
      {
      protected:
        virtual
        ~buffer_base ()
        {
          if (free_ && data_)
            operator delete (data_);
        }
 
        buffer_base ()
            : data_ (0), size_ (0), capacity_ (0), free_ (true)
        {
        }
 
      protected:
        char* data_;
        size_t size_;
        size_t capacity_;
        bool free_;
      };
 
      //@endcond
 
      template<typename C>
      class buffer: protected buffer_base
      {
      public:
        typedef std::size_t size_t;
 
      public:
 
        explicit
        buffer (size_t size = 0);
 
        buffer (size_t size, size_t capacity);
 
        buffer (const void* data, size_t size);
 
        buffer (const void* data, size_t size, size_t capacity);
 
        buffer (void* data,
                size_t size,
                size_t capacity,
                bool assume_ownership);
 
        buffer (const buffer& x);
 
 
      public:
        buffer&
        operator= (const buffer& x);
 
      public:
        size_t
        capacity () const
        {
          return capacity_;
        }
 
        bool
        capacity (size_t c)
        {
          return this->capacity (c, true);
        }
 
      public:
        size_t
        size () const {return size_;}
 
        bool
        size (size_t s)
        {
          bool r (false);
 
          if (s > capacity_)
            r = capacity (s);
 
          size_ = s;
 
          return r;
        }
 
      public:
        const char*
        data () const {return data_;}
 
        char*
        data () {return data_;}
 
        const char*
        begin () const {return data_;}
 
        char*
        begin () {return data_;}
 
        const char*
        end () const {return data_ + size_;}
 
        char*
        end () {return data_ + size_;}
 
      public:
        void
        swap (buffer& x);
 
      private:
        bool
        capacity (size_t capacity, bool copy);
      };
 
      template <typename C>
      inline bool
      operator== (const buffer<C>& a, const buffer<C>& b)
      {
        return a.size () == b.size () &&
          std::memcmp (a.data (), b.data (), a.size ()) == 0;
      }
 
      template <typename C>
      inline bool
      operator!= (const buffer<C>& a, const buffer<C>& b)
      {
        return !(a == b);
      }
    }
  }
}
 
#include <xsd/cxx/tree/buffer.txx>
 
#endif  // XSD_CXX_TREE_BUFFER_HXX