---

CTBvector.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 <assert.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"
#include "CTBnum.hxx"
#include "CTBosFill.hxx"
#include "CTBexceptionIndexRange.hxx"
#include "CTBvector.hxx"

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

template <class T>
CTBvector<T>::CTBvector(CTBint i_size)
  : m_rbuf(i_size),
    mi_nuse(0)
{
  CTB_Trace("CTBvector(CTBint)");

  m_rbuf.ConstructRange(0,i_size);
  mi_nuse = i_size;
}

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

template <class T>
CTBvector<T>::CTBvector(CTBint i_size, const T& def)
  : m_rbuf(i_size),
    mi_nuse(0)
{
  CTB_Trace("CTBvector(CTBint,const T&)");

  m_rbuf.ConstructRange(0,i_size,def);
  mi_nuse = i_size;
}

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

template <class T>
CTBvector<T>::CTBvector(const CTBvector<T>& rhs)
  : m_rbuf(rhs.mi_nuse),
    mi_nuse(0)
{
  CTB_Trace("CTBvector(const CTBvector&)");

  m_rbuf.ConstructRange(0,rhs.mi_nuse, (const T*) rhs);
  mi_nuse = rhs.mi_nuse;
}

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

template <class T>
CTBvector<T>::~CTBvector()
{
  CTB_Trace("~CTBvector()");

  assert(mi_nuse <= m_rbuf.Capacity());     // !?! size <= capacity
  m_rbuf.DestructRange(0,mi_nuse);
}

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

template <class T>
T& CTBvector<T>::At(CTBint i_ind)
{
  CTB_Trace("CTBvector::At(CTBint)");
  if (i_ind < 0 || i_ind >= mi_nuse) 
    throw CTBexceptionIndexRange(i_ind,mi_nuse,"CTBvector::At()");
  return m_rbuf[i_ind];
}

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

template <class T>
const T& CTBvector<T>::At(CTBint i_ind) const
{
  CTB_Trace("CTBvector::At(CTBint)");
  if (i_ind < 0 || i_ind >= mi_nuse) 
    throw CTBexceptionIndexRange(i_ind,mi_nuse,"CTBvector::At()");
  return m_rbuf[i_ind];
}

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

template <class T>
void CTBvector<T>::Resize(CTBint i_size)
{
  CTB_Trace("CTBvector::Resize(CTBint)");

  if (i_size < mi_nuse) {                   // downsize
    m_rbuf.DestructRange(i_size,mi_nuse-i_size);
    mi_nuse = i_size;

  } else if (i_size > mi_nuse) {            // upsize
    if (i_size > Capacity()) ChangeCapacity(i_size);
    m_rbuf.ConstructRange(mi_nuse,i_size-mi_nuse);
    mi_nuse = i_size;
  }
  return;
}

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

template <class T>
void CTBvector<T>::Resize(CTBint i_size, const T& def)
{
  CTB_Trace("CTBvector::Resize(CTBint,const T&)");

  if (i_size < mi_nuse) {                   // downsize
    m_rbuf.DestructRange(i_size,mi_nuse-i_size);
    mi_nuse = i_size;

  } else if (i_size > mi_nuse) {            // upsize
    if (i_size > Capacity()) ChangeCapacity(i_size);
    m_rbuf.ConstructRange(mi_nuse,i_size-mi_nuse,def);
    mi_nuse = i_size;
  }
  return;
}

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

template <class T>
void CTBvector<T>::Insert(CTBint i_ind, const T& rhs)
{
  CTB_Trace("CTBvector::Insert(CTBint,const T&)");

  assert(i_ind >= 0);                       // !?! valid index
  assert(i_ind <= mi_nuse);                 // !?! valid or beyond-the-end

  if (mi_nuse+1 > Capacity()) IncreaseCapacity(mi_nuse+1); // double if needed
  
  if (i_ind == mi_nuse) {                   // insert at tail
    m_rbuf.Construct(mi_nuse,rhs);
  } else {                                  // insert elsewhere
    m_rbuf.Construct(mi_nuse,m_rbuf[mi_nuse-1]); // new last element
    m_rbuf.ShiftRight(i_ind,mi_nuse-2);     // shift stuff inbetween
    m_rbuf[i_ind] = rhs;                    // finally insert
  }
  
  mi_nuse += 1;
  return;
}

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

template <class T>
void CTBvector<T>::Delete(CTBint i_ind)
{
  CTB_Trace("CTBvector::Delete(CTBint)");

  assert(i_ind >= 0);                       // !?! valid index
  assert(i_ind < mi_nuse);

  m_rbuf.ShiftLeft(i_ind+1,mi_nuse-1);      // shift stuff left
  m_rbuf.Destruct(mi_nuse-1);               // destruct last element
  mi_nuse -= 1;
  return;
}

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

template <class T>
void CTBvector<T>::IncreaseCapacity(CTBint i_cap)
{
  if (i_cap > Capacity()) ChangeCapacity(CTBmax(i_cap,CTBmax(4,2*Capacity())));
  return;
}

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

template <class T>
void CTBvector<T>::Grab(CTBvector<T>& rhs)
{
  assert(mi_nuse <= m_rbuf.Capacity());     // !?! size <= capacity
  m_rbuf.DestructRange(0,mi_nuse);          // destroy old stuff
  m_rbuf.Resize(0);                         // drop old buffer
  m_rbuf.Grab(rhs.m_rbuf);                  // finally grab rhs
  mi_nuse     = rhs.mi_nuse;
  rhs.mi_nuse = 0;
  return;
}

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

template <class T>
void CTBvector<T>::Dump(int i_indent, ostream& os, const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBvector<T> ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;
  os << bl << "  mi_nuse:       " << mi_nuse << endl;
  m_rbuf.Dump(i_indent+2,os);
  return;
}

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

template <class T>
CTBvector<T>& CTBvector<T>::operator=(const T& rhs)
{
  CTB_Trace("CTBvector::operator=(const T&)");

  m_rbuf.Copy(0,mi_nuse,rhs);
  return *this;
}

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

template <class T>
CTBvector<T>& CTBvector<T>::operator=(const CTBvector<T>& rhs)
{
  CTB_Trace("CTBvector::operator=(const CTBvector&)");
  CTBint i_size = rhs.Size();

  m_rbuf.DestructRange(0,mi_nuse);
  mi_nuse = 0;
  
  EnsureCapacity(i_size);

  m_rbuf.ConstructRange(0,i_size,(const T*) rhs);
  mi_nuse = i_size;
  return *this;
}

//------------------------------------------+-----------------------------------
 
template <class T>
CTBvector<T>& CTBvector<T>::operator=(const CTBvectorCDsc<T>& rhs)
{
  CTB_Trace("CTBvector::operator=(const CTBvectorCDsc&)");
  CTBint i_size = rhs.Size();
   T*    p_ele;

  m_rbuf.DestructRange(0,mi_nuse);
  mi_nuse = 0;
  
  EnsureCapacity(i_size);

  p_ele = m_rbuf;
  for (CTBint i = 0; i < i_size; i++)  {
    m_rbuf.Construct(p_ele,rhs(i));
    p_ele += 1;
  }
  
  mi_nuse = i_size;
  return *this;
}

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

template <class T>
void CTBvector<T>::ChangeCapacity(CTBint i_cap)
{
  CTB_Trace("CTBvector::ChangeCapacity(CTBint)");
  CTBint i_size = Size();                   // vector size
  CTBrawBuffer<T> old_rbuf(m_rbuf,true);    // grab old rawbuffer

  m_rbuf.Resize(i_cap);                     // new buffer

  for (CTBint i = 0; i < i_size; i++) {     // copy and release elements
    m_rbuf.GrabConstruct(i,old_rbuf[i]);
    old_rbuf.Destruct(i);
  }
  return;
}

//------------------------------------------+-----------------------------------
#if (defined(CTB__NoInline) || defined(CTBvector__NoInline))
#define inline
#include "CTBvector.icc"
#undef  inline
#endif

---