---

CTBvector.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 "CTBexceptionIndexRange.hxx"

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

template <class T>
inline CTBvector<T>::CTBvector()
  : m_rbuf(),
    mi_nuse(0)
{}

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

template <class T>
inline CTBvector<T>::CTBvector(CTBvector<T>& rhs, bool )
  : m_rbuf(rhs.m_rbuf,true),
    mi_nuse(rhs.mi_nuse)
{
  rhs.mi_nuse = 0;
}

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

template <class T>
inline CTBvector<T>::CTBvector(CTBvector<T>::RetObj& rhs)
  : m_rbuf(rhs.m_rbuf,true),
    mi_nuse(rhs.mi_nuse)
{
  rhs.mi_nuse = 0;
}

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

template <class T>
inline CTBint CTBvector<T>::Size() const
{
  return mi_nuse;
}

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

template <class T>
inline CTBint CTBvector<T>::Capacity() const
{
  return m_rbuf.Capacity();
}

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

template <class T>
inline CTBvectorDsc<T> CTBvector<T>::Reverse()
{
  return CTBvectorDsc<T>(m_rbuf+mi_nuse-1,mi_nuse,-1);
}

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

template <class T>
inline CTBvectorCDsc<T> CTBvector<T>::Reverse() const
{
  return CTBvectorCDsc<T>(m_rbuf+mi_nuse-1,mi_nuse,-1);
}

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

template <class T>
inline void CTBvector<T>::Remove(CTBint i_ind, T& rhs)
{
  rhs = m_rbuf[i_ind];
  Delete(i_ind);
  return;
}

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

template <class T>
inline void CTBvector<T>::InsertHead(const T& rhs)
{
  Insert(0,rhs);
  return;
}

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

template <class T>
inline bool CTBvector<T>::RemoveHead(T& rhs)
{
  bool b_ok = mi_nuse > 0;
  if (b_ok) Remove(0,rhs);
  return b_ok;
}

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

template <class T>
inline void CTBvector<T>::InsertTail(const T& rhs)
{
  if (mi_nuse+1 > Capacity()) IncreaseCapacity(mi_nuse+1); // double if needed
  m_rbuf.Construct(mi_nuse,rhs);
  mi_nuse += 1;
  return;
}

// Note:
//  1. This equivalent to Insert(mi_nuse,rhs), but fully inlined and thus
//     potentially faster. For types with an inlined copy ctor this executes
//     without call overhead unless a reallocation is needed.

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

template <class T>
inline bool CTBvector<T>::RemoveTail(T& rhs)
{
  if (mi_nuse == 0) return false;
  m_rbuf.GrabDestruct(mi_nuse-1,rhs);
  mi_nuse -= 1;
  return true;
}

// Note:
//  1. This roughly equivalent to 
//              if (mi_nuse>0) Remove(mi_nuse-1,rhs);
//     but fully inlined and thus potentially faster.

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

template <class T>
inline void CTBvector<T>::EnsureCapacity(CTBint i_cap)
{
  if (i_cap > Capacity()) ChangeCapacity(i_cap);
  return;
}

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

template <class T>
inline void CTBvector<T>::TrimCapacity()
{
  if (Size() < Capacity()) ChangeCapacity(Size());
  return;
}

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

template <class T>
inline const T* CTBvector<T>::Data() const
{
  return *this;
}

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

template <class T>
inline CTBint CTBvector<T>::Stride() const
{
  return 1;
}

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

template <class T>
inline T& CTBvector<T>::operator[](CTBint i_ind)
{
#ifndef CTB__IndexCheck
  return m_rbuf[i_ind];
#else
  return At(i_ind);
#endif
}

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

template <class T>
inline const T& CTBvector<T>::operator[](CTBint i_ind) const
{
#ifndef CTB__IndexCheck
  return m_rbuf[i_ind];
#else
  return At(i_ind);
#endif
}

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

template <class T>
inline T& CTBvector<T>::operator()(CTBint i_ind)
{
#ifndef CTB__IndexCheck
  return m_rbuf[i_ind];
#else
  return At(i_ind);
#endif
}

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

template <class T>
inline const T& CTBvector<T>::operator()(CTBint i_ind) const
{
#ifndef CTB__IndexCheck
  return m_rbuf[i_ind];
#else
  return At(i_ind);
#endif
}

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

template <class T>
inline CTBvectorDsc<T> CTBvector<T>::operator()(const CTBrange& ran)
{
#ifndef CTB__IndexCheck
  CTBindexRangeCheck(ran,mi_nuse,"CTBvector<T>::operator()");
#endif
  return CTBvectorDsc<T>(m_rbuf,ran);
}

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

template <class T>
inline CTBvectorCDsc<T> CTBvector<T>::operator()(const CTBrange& ran) const
{
#ifndef CTB__IndexCheck
  CTBindexRangeCheck(ran,mi_nuse,"CTBvector<T>::operator()");
#endif
  return CTBvectorCDsc<T>(m_rbuf,ran);
}

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

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

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

template <class T>
inline CTBvector<T>::operator T*()
{
  return (mi_nuse > 0) ? (T*) m_rbuf : 0;
}

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

template <class T>
inline CTBvector<T>::operator const T*() const
{
  return (mi_nuse > 0) ? (const T*) m_rbuf : 0;
}

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

template <class T>
inline CTBvector<T>::operator CTBvectorDsc<T>()
{
  return CTBvectorDsc<T>(m_rbuf,mi_nuse);
}

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

template <class T>
inline CTBvector<T>::operator CTBvectorCDsc<T>() const
{
  return CTBvectorCDsc<T>(m_rbuf,mi_nuse);
}

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

template <class T>
inline CTBvector<T>& CTBvector<T>::operator=(CTBvector<T>::RetObj& rhs)
{
  Grab(rhs);
  return *this;
}

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

template <class T>
inline CTBvector<T>& CTBvector<T>::operator<<(const T& rhs)
{
  InsertTail(rhs);
  return *this;
}

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

template <class T>
inline CTBvector<T>& CTBvector<T>::operator>>(T& rhs)
{
  RemoveTail(rhs);
  return *this;
}

//------------------------------------------+-----------------------------------
template <class T>
inline ostream& operator<<(ostream& os, const CTBvector<T>& obj)
{
  int i_width = os.width();

  os << setw(0) << "{";
  for (CTBint i = 0; i < obj.Size(); i++) {
    if (i > 0) os << ",";
    os << setw(i_width) << obj(i);
  }
  os << "}";
  return os;
}

---