buffer_vector.hxx

Go to the documentation of this file.

#pragma once
#ifndef OPENGM_BUFFER_VECTOR_HXX
#define  OPENGM_BUFFER_VECTOR_HXX

#include <vector>
#include <algorithm>

#include "opengm/opengm.hxx"


namespace opengm{
   template<class T>
   class BufferVector{
      public:
         typedef T ValueType;
         typedef T value_type;
         typedef T const * ConstIteratorType;
         typedef T const * const_iterator;
         typedef T * IteratorType;
         typedef T * iterator;
         BufferVector( );
         BufferVector(const size_t );
         BufferVector(const size_t ,const T & );
         BufferVector(const BufferVector<T> &);
         ~BufferVector( );
         BufferVector<T> & operator= (const BufferVector<T> &);
         size_t size() const ;
         T const * begin() const;
         T const * end() const;
         T * const begin();
         T * const end();
         
         T const * data() const;
         T * data();
         
         T const & operator[](const size_t)const;
         T & operator[](const size_t);
         void push_back(const T &);
         void resize(const size_t );
         void reserve(const size_t );
         void clear();
         bool empty()const;
         const T & front()const;
         const T & back()const;
         T & front();
         T & back();
         template<class ITERATOR>
         void assign(ITERATOR ,ITERATOR);
      private:
         size_t size_;
         size_t capacity_;
         T * data_;
   };
   template<class T>
   inline BufferVector<T>::BufferVector( )
   :  size_(0),
      capacity_(0),
      data_(NULL) {
   }
   
   template<class T>
   inline BufferVector<T>::BufferVector
   (
      const size_t size
   )
   :  size_(size),
      capacity_(size) {
      if(size_!=0) {
      data_ = new T[size];
      }
   }
   
   template<class T>
   inline BufferVector<T>::BufferVector
   (
      const size_t size,
      const T & value
   )
   :  size_(size),
      capacity_(size) {
      data_ = new T[size];
      std::fill(data_,data_+size_,value);
   }
   
   
   template<class T>
   inline BufferVector<T>::BufferVector
   (
      const  BufferVector<T> & other
   )
   :  size_(other.size_),
      capacity_(other.size_)
   {
      if(size_!=0) {
         data_ = new T[size_];
         std::copy(other.data_,other.data_+size_,data_);
      }
   }
   
   template<class T>
   inline T const * 
   BufferVector<T>::data() const{
      return data_;
   }
   
   template<class T>
   inline T * 
   BufferVector<T>::data() {
      return data_;
   }
   
   template<class T>
   inline BufferVector<T>::~BufferVector( ) {
      if(capacity_!=0) {
         OPENGM_ASSERT(data_!=NULL);
         delete[] data_;
      }
   }
   
   template<class T>
   inline BufferVector<T> & BufferVector<T>::operator=
   (
      const  BufferVector<T> & other
   )
   {
      if(&other!=this) {
         size_=other.size_;
         if(size_>capacity_) {
            delete [] data_;
            data_ = new T[size_];
            capacity_=size_;
         }
         std::copy(other.data_,other.data_+size_,data_);
      }
      return *this;
   }
   
   template<class T>
   inline size_t
   BufferVector<T>::size() const {
      OPENGM_ASSERT(data_!=NULL ||size_== 0 );
      return size_;
   }
   
   template<class T>
   inline T const *
   BufferVector<T>::begin() const{
      OPENGM_ASSERT(data_!=NULL);
      return data_;
   }
   
   template<class T>
   inline T const *
   BufferVector<T>::end() const{
      OPENGM_ASSERT(data_!=NULL);
      return data_ + size_;
   }
   
   template<class T>
   inline T * const
   BufferVector<T>::begin() {
      OPENGM_ASSERT(data_!=NULL);
      return data_;
   }
   
   template<class T>
   inline T * const
   BufferVector<T>::end() {
      OPENGM_ASSERT(data_!=NULL);
      return data_ + size_;
   }
   
   template<class T>
   inline T const &
   BufferVector<T>::operator[]
   (
      const size_t index
   )const{
      OPENGM_ASSERT(data_!=NULL);
      OPENGM_ASSERT(index<size_);
      return data_[index];
   }
   
   template<class T>
   inline T &
   BufferVector<T>::operator[]
   (
      const size_t index
   ) {
      OPENGM_ASSERT(index<size_);
      return data_[index];
   }
   
   template<class T>
   inline void
   BufferVector<T>::push_back
   (
      const T & value
   ) {
      OPENGM_ASSERT(size_<=capacity_);
      if(capacity_==size_) {
         if(size_!=0) {
            T * tmp=new T[capacity_*2];
            std::copy(data_,data_+size_,tmp);
            delete[] data_;
            capacity_*=2;
            data_=tmp;
         }
         else{
            T * tmp=new T[2];
            capacity_=2;
            data_=tmp;
         }
      }
      data_[size_]=value;
      ++size_;
      OPENGM_ASSERT(size_<=capacity_);
   }
   
   template<class T>
   inline void
   BufferVector<T>::resize
   (
      const size_t size
   ) {
      OPENGM_ASSERT(size_<=capacity_);
      if(size>capacity_) {
         if(size_!=0) {
            T * tmp=new T[size];
            std::copy(data_,data_+size_,tmp);
            delete[] data_;
            capacity_=size;
            data_=tmp;
         }
         else{
            data_=new T[size];
            capacity_=size;
         }
      }
      size_=size;
      OPENGM_ASSERT(size_<=capacity_);
   }
   
   template<class T>
   inline void
   BufferVector<T>::reserve
   (
      const size_t size
   ) {
      OPENGM_ASSERT(size_<=capacity_);
      if(size>capacity_) {
         if(size_!=0) {
            T * tmp=new T[size];
            std::copy(data_,data_+size_,tmp);
            delete[] data_;
            data_=tmp;
         }
         else{
            data_=new T[size];
         }
         size_=size;
         capacity_=size;
      }
      //size_=size;
      OPENGM_ASSERT(size_<=capacity_);
   }
   
   template<class T>
   inline void
   BufferVector<T>::clear() {
      OPENGM_ASSERT(size_<=capacity_);
      size_=0;
   }
   
   template<class T>
   inline bool
   BufferVector<T>::empty()const{
      return size_==0 ? true:false;
   }
   
   template<class T>
   template<class ITERATOR>
   inline void
   BufferVector<T>::assign(ITERATOR begin,ITERATOR end) {
      this->resize(std::distance(begin,end));
      std::copy(begin, end, data_);
   }
   
   template<class T>
   inline const T &
   BufferVector<T>::back()const{
      return data_[size_-1];
   }

   template<class T>
   inline T &
   BufferVector<T>::back() {
      return data_[size_-1];
   }
   
   template<class T>
   inline const T &
   BufferVector<T>::front()const{
      return data_[0];
   }
   
   template<class T>
   inline T &
   BufferVector<T>::front() {
      return data_[0];
   }
}


#endif   //OPENGM_BUFFER_VECTOR_HXX