---

CTBrawBuffer.icc

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include <assert.h>
#include <new.h>

#include "CTBgrab.hxx"
#include "CTBosFill.hxx"

//------------------------------------------+-----------------------------------

template <class T>
inline CTBrawBuffer<T>::CTBrawBuffer()
  : mp_data(0),
    mi_capacity(0)
{}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBrawBuffer<T>::CTBrawBuffer(CTBint i_capacity)
  : mp_data(0),
    mi_capacity(0)
{
  CreateBuffer(i_capacity);
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBrawBuffer<T>::CTBrawBuffer(CTBrawBuffer<T>& rhs,bool )
  : mp_data(rhs.mp_data),                   // copy rhs -> lhs
    mi_capacity(rhs.mi_capacity)
{
  rhs.mp_data     = 0;                      // reset rhs
  rhs.mi_capacity = 0;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBrawBuffer<T>::~CTBrawBuffer()
{
  DeleteBuffer();
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Construct(CTBint i_ind)
{
  assert(i_ind >= 0 && i_ind < mi_capacity); // !?! index in range
  new(mp_data+i_ind) T();                   // use default constructor
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Construct(T* p_ele)
{
  assert(mp_data && p_ele >= mp_data && p_ele < mp_data+mi_capacity); // !?!
  new(p_ele) T();                           // use default constructor
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::ConstructRange(CTBint i_beg, CTBint i_size)
{
  T* p_cur = mp_data + i_beg;
  
  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) new(p_cur++) T();
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Construct(CTBint i_ind, const T& value)
{
  assert(i_ind >= 0 && i_ind < mi_capacity); // !?! index in range
  new(mp_data+i_ind) T(value);              // use copy constructor
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Construct(T* p_ele, const T& value)
{
  assert(mp_data && p_ele >= mp_data && p_ele < mp_data+mi_capacity); // !?!
  new(p_ele) T(value);                      // use copy constructor
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::ConstructRange(CTBint i_beg, CTBint i_size,
                                            const T& value)
{
  T* p_cur = mp_data + i_beg;
  
  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) new(p_cur++) T(value);
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::ConstructRange(CTBint i_beg, CTBint i_size,
                                            const T rhs[])
{
  T* p_cur = mp_data + i_beg;
  
  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) new(p_cur++) T(rhs[i]);
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Destruct(CTBint i_ind)
{
  assert(i_ind >= 0 && i_ind < mi_capacity); // !?! index in range
  (mp_data+i_ind)->~T();                    // explicit destructor call
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Destruct(T* p_ele)
{
  assert(mp_data && p_ele >= mp_data && p_ele < mp_data+mi_capacity); // !?!
  p_ele->~T();                              // explicit destructor call
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::DestructRange(CTBint i_beg, CTBint i_size)
{
  T* p_cur = mp_data + i_beg;

  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) (p_cur++)->~T();
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::GrabConstruct(CTBint i_ind, T& value)
{
  CTBgrab<T> grab;
  
  assert(i_ind >= 0 && i_ind < mi_capacity); // !?! index in range
  grab.Construct(mp_data+i_ind,value);
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::GrabConstructRange(CTBint i_beg, 
                                                CTBint i_size, T rhs[])
{
  CTBgrab<T> grab;
  T* p_cur = mp_data + i_beg;
  
  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) grab.Construct(p_cur++,rhs[i]);
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::GrabDestruct(CTBint i_ind, T& obj)
{
  CTBgrab<T> grab;
  
  assert(i_ind >= 0 && i_ind < mi_capacity); // !?! index in range
  grab.Destruct(obj, mp_data+i_ind);
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBint CTBrawBuffer<T>::Capacity() const
{
  return mi_capacity;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Resize(CTBint i_capacity)
{
  DeleteBuffer();
  CreateBuffer(i_capacity);
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Grab(CTBrawBuffer<T>& rhs)
{
  assert(!mp_data && this != &rhs);         // !?! must be empty; no self grab
  mp_data         = rhs.mp_data;            // copy rhs -> lhs
  mi_capacity     = rhs.mi_capacity;
  rhs.mp_data     = 0;                      // reset rhs
  rhs.mi_capacity = 0;
  return;
}
//------------------------------------------+-----------------------------------

template <class T>
inline bool CTBrawBuffer<T>::Empty() const
{
  return !mp_data;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::ShiftRight(CTBint i_beg, CTBint i_end)
{
  CTBgrab<T> grab;
  T*  p_cur = mp_data + i_end+1;

  assert(i_beg > i_end || (i_beg >= 0 && i_end >= 0 && // !?! 
                           i_end < mi_capacity));
  for (CTBint i_n = i_end - i_beg + 1; i_n > 0; i_n--) {
    grab(p_cur[0],p_cur[-1]);               // p_cur[0] = p_cur[-1]; 
    p_cur--;
  }
  
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::ShiftLeft(CTBint i_beg, CTBint i_end)
{
  CTBgrab<T> grab;
  T*  p_cur = mp_data + i_beg-1;

  assert(i_beg > i_end || (i_beg >= 0 && i_end >= 0 && // !?! 
                           i_end < mi_capacity));
  for (CTBint i_n = i_end - i_beg + 1; i_n > 0; i_n--) {
    grab(p_cur[0],p_cur[1]);                // p_cur[0] = p_cur[1];
    p_cur++;
  }
  
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Copy(CTBint i_beg, CTBint i_size, const T& rhs)
{
  T*  p_cur = mp_data + i_beg;

  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) *p_cur++ = rhs;  
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Copy(          // copy array into rawbuffer
    CTBint i_beg,                           //   first index target range
    CTBint i_size,                          //   number of elements to copy
    const T rhs[])                          //   source array
{
  T*  p_cur = mp_data + i_beg;

  assert(i_size <= 0 || (i_beg >= 0 && i_beg+i_size <= mi_capacity)); // !?!
  for (CTBint i = 0; i < i_size; i++) *p_cur++ = rhs[i];  
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::Dump(int i_indent, ostream& os,
                                  const char* p_text) const
{
  CTBosFill bl(i_indent);

  os << bl << "--CTBrawBuffer<T> ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;
  os << bl << "  mp_data:       " << (void*) mp_data;
  if (mp_data) os << " ... " << (void*) (mp_data + (mi_capacity-1));
  os << endl;
  os << bl << "  mi_capacity:   " << mi_capacity << endl;
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline T& CTBrawBuffer<T>::operator[](CTBint i_ind)
{
  return mp_data[i_ind];
}

//------------------------------------------+-----------------------------------

template <class T>
inline T* CTBrawBuffer<T>::operator+(CTBint i_ind)
{
  return mp_data+i_ind;
}

//------------------------------------------+-----------------------------------

template <class T>
inline const T* CTBrawBuffer<T>::operator+(CTBint i_ind) const
{
  return mp_data+i_ind;
}

//------------------------------------------+-----------------------------------

template <class T>
inline const T& CTBrawBuffer<T>::operator[](CTBint i_ind) const
{
  return mp_data[i_ind];
}

//------------------------------------------+-----------------------------------

template <class T>
inline bool CTBrawBuffer<T>::operator !() const
{
  return mi_capacity == 0;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBrawBuffer<T>::operator T*()
{
  return mp_data;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBrawBuffer<T>::operator const T*() const
{
  return mp_data;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::DeleteBuffer()
{
  if (mp_data != 0) {
    ::operator delete(mp_data);
    mp_data     = 0;
    mi_capacity = 0;
  }
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBrawBuffer<T>::CreateBuffer(CTBint i_capacity)
{
  assert(!mp_data);                         // !?! must be in empty state
  if (i_capacity > 0) {
    mp_data = (T*) ::operator new(i_capacity * sizeof(T));
  } else {
    mp_data = 0;
  }
  mi_capacity = i_capacity;
  return;
}

---