---

CTBsharedBuffer.cxx

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 "CTB.hxx"
#include "CTB_Trace.hxx"

#include "CTBnum.hxx"
#include "CTBexceptionIndexRange.hxx"
#include "CTBosFill.hxx"
#include "CTBsharedBuffer.hxx"

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

template <class T>
const T& CTBsharedBuffer<T>::At(CTBint i_ind) const
{
  CTB_Trace("CTBsharedBuffer::At(CTBint) const");

  if (i_ind < 0 || i_ind >= mi_size) 
    throw CTBexceptionIndexRange(i_ind,mi_size,"CTBsharedBuffer::At()");
  return mp_data[i_ind];
}

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

template <class T>
T& CTBsharedBuffer<T>::At(CTBint i_ind)
{
  CTB_Trace("CTBsharedBuffer::At(CTBint)");

  if (i_ind < 0 || i_ind >= mi_size) 
    throw CTBexceptionIndexRange(i_ind,mi_size,"CTBsharedBuffer::At()");
  return mp_data[i_ind];
}

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

template <class T>
void CTBsharedBuffer<T>::Release()
{
  CTB_Trace("CTBsharedBuffer::Release()");

  if (mp_refcount) {                        // refering to a buffer ?
    if (mp_refcount->Decrement()) {         // last reference ?
      delete [] mp_data;                    // then delete buffer
      delete    mp_refcount;
    }
    mp_data     = 0;                        // zero all references
    mi_size     = 0;
    mp_refcount = 0;
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::Unshare()
{
  CTB_Trace("CTBsharedBuffer::Unshare()");

  if (IsShared()) {
    CTBsharedBuffer<T>  old(*this,true);    // grab copy of buffer
    CreateBuffer(old.Size());               // allocate new one
    CopyData(old.Data(),old.Size());        // and copy elements
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::Resize(CTBint i_size, bool b_keep)
{
  CTB_Trace("CTBsharedBuffer::Resize(CTBint, bool)");

  if (IsNull()) {
    CreateBuffer(i_size);
  } else {
    if (i_size != Size() || IsShared()) {   // new size or shared
      CTBsharedBuffer<T>  old(*this,true);  // grab copy of buffer
      CreateBuffer(i_size);
      if (b_keep) CopyData(old.Data(),old.Size());
    }
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::Grab(CTBsharedBuffer<T>& rhs)
{
  CTB_Trace("CTBsharedBuffer::Grab(CTBsharedBuffer&)");

  if (this != &rhs) {                       // protect against self grab ...
    Release();                              // drop old stuff
    mp_data         = rhs.mp_data;          // transfer context
    mi_size         = rhs.mi_size;
    mp_refcount     = rhs.mp_refcount;
    rhs.mp_data     = 0;                    // set rhs to IsNull state
    rhs.mi_size     = 0;
    rhs.mp_refcount = 0;
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::SharedCopy(const CTBsharedBuffer<T>& rhs)
{
  CTB_Trace("CTBsharedBuffer::SharedCopy(const CTBsharedBuffer&)");

  if (*this != rhs) {
    Release();
    mp_data      = rhs.mp_data;
    mi_size      = rhs.mi_size;
    mp_refcount  = rhs.mp_refcount;
    if (mp_refcount) mp_refcount->Increment();
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::PrivateCopy(const CTBsharedBuffer<T>& rhs)
{
  CTB_Trace("CTBsharedBuffer::PrivateCopy(const CTBsharedBuffer&)");

  if (*this != rhs) {
    Release();
    CreateBuffer(rhs.Size());
    CopyData(rhs.Data(),rhs.Size());
  } else {
    Unshare();
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::Dump(int i_indent, ostream& os,
                              const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBsharedBuffer<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_size-1));
  os << endl;
  os << bl << "    mi_size:       " << mi_size << endl;
  os << bl << "    mp_refcount:   " << mp_refcount;
  if (mp_refcount)  os << "    (" << *mp_refcount << ")"; 
  os << endl;
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::CreateBuffer(CTBint i_size)
{
  CTB_Trace("CTBsharedBuffer::CreateBuffer(CTBint)");

  mi_size = i_size;
  if (i_size > 0) {
    mp_data     = new T [i_size];
    mp_refcount = new CTBreferenceCounter;
  } else {
    mp_data     = 0;
    mp_refcount = 0;
  }
  return;
}

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

template <class T>
void CTBsharedBuffer<T>::CopyData(const T rhs[], CTBint i_size)
{
  CTB_Trace("CTBsharedBuffer::CopyData(const T[], CTBint)");
  CTBint i_n = CTBmin(i_size,Size());       // limit copy size

  for (int i = 0; i < i_n ; i++) mp_data[i] = rhs[i];
  return;
}

---