---

CTBvectorDsc.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 "CTBnum.hxx"
#include "CTBosFill.hxx"
#include "CTBexceptionIndexRange.hxx"
#include "CTBexceptionConformity.hxx"

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

template <class T>
inline CTBvectorCDsc<T>::CTBvectorCDsc()
  : mp_data(0),
    mi_size(0),
    mi_stride(0)
{}

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

template <class T>
inline CTBvectorCDsc<T>::CTBvectorCDsc(const T* p_data, CTBint i_size, 
                                       CTBint i_stride)
  : mp_data(i_size > 0 ? (T*) p_data : 0),
    mi_size(i_size),
    mi_stride(i_stride)
{}

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

template <class T>
inline CTBvectorCDsc<T>::CTBvectorCDsc(const T* p_data, CTBrange ran)
{
  mp_data = (T*)p_data + ran.Begin();
  if (ran.End() >= ran.Begin()) {
    mi_size   = ran.End()-ran.Begin()+1;
    mi_stride =  1;
  } else {
    mi_size   = ran.Begin()-ran.End()+1;
    mi_stride = -1;
  }
}

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

template <class T>
inline CTBvectorCDsc<T>::CTBvectorCDsc(const T* p_data, CTBint i_stride,
                                       CTBrange ran)
{
  mp_data = (T*)p_data + i_stride*ran.Begin();
  if (ran.End() >= ran.Begin()) {
    mi_size   = ran.End()-ran.Begin()+1;
    mi_stride = i_stride;
  } else {
    mi_size   = ran.Begin()-ran.End()+1;
    mi_stride = -i_stride;
  }
}

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

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

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

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

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

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

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

template <class T>
inline void CTBvectorCDsc<T>::Dump(int i_indent, ostream& os, 
                                   const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBvectorCDsc<T> ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;
  os << bl << "  mp_data:       " << (void*) mp_data << endl;
  os << bl << "  mi_size:       " << mi_size << endl;
  os << bl << "  mi_stride:     " << mi_stride << endl;
  return;  
}

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

template <class T>
inline const T& CTBvectorCDsc<T>::operator[](CTBint i_ind) const
{
#ifdef CTB__IndexCheck
  CTBindexRangeCheck(i_ind,mi_size,"CTBvectorCDsc::operator[]");
#endif
  return mp_data[mi_stride*i_ind];
}

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

template <class T>
inline const T& CTBvectorCDsc<T>::operator()(CTBint i_ind) const
{
#ifdef CTB__IndexCheck
  CTBindexRangeCheck(i_ind,mi_size,"CTBvectorCDsc::operator()");
#endif
  return mp_data[mi_stride*i_ind];
}

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

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

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

template <class T>
inline CTBvectorCDsc<T>::operator void* () const
{
  return mp_data;                           // note: != 0 only if mi_size > 0 
}

//------------------------------------------+-----------------------------------
template <class T>
inline ostream& operator<<(ostream& os, CTBvectorCDsc<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;
}

//##############################################################################
//------------------------------------------+-----------------------------------

template <class T>
inline CTBvectorDsc<T>::CTBvectorDsc()
  : CTBvectorCDsc<T>()
{}

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

template <class T>
inline CTBvectorDsc<T>::CTBvectorDsc(T* p_data, CTBint i_size, CTBint i_stride)
  : CTBvectorCDsc<T>(p_data,i_size,i_stride)
{}

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

template <class T>
inline CTBvectorDsc<T>::CTBvectorDsc(T* p_data, CTBrange ran)
  : CTBvectorCDsc<T>(p_data,ran)
{}

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

template <class T>
inline CTBvectorDsc<T>::CTBvectorDsc(T* p_data, CTBint i_stride, CTBrange ran)
  : CTBvectorCDsc<T>(p_data,i_stride,ran)
{}

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

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

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

template <class T>
inline T& CTBvectorDsc<T>::operator[](CTBint i_ind) const
{
#ifdef CTB__IndexCheck
  CTBindexRangeCheck(i_ind,mi_size,"CTBvectorCDsc::operator[]");
#endif
  return mp_data[mi_stride*i_ind];
}

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

template <class T>
inline T& CTBvectorDsc<T>::operator()(CTBint i_ind) const
{
#ifdef CTB__IndexCheck
  CTBindexRangeCheck(i_ind,mi_size,"CTBvectorCDsc::operator()");
#endif
  return mp_data[mi_stride*i_ind];
}

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

template <class T>
const CTBvectorDsc<T>& CTBvectorDsc<T>::operator=(const T& rhs) const
{
  T* po = mp_data;
  
  for (CTBint i = 0; i < mi_size; i++) {
    *po = rhs;
    po += mi_stride;
  }
  return *this;
}

// Note:
//  1. the return type must be const CTBvectorDsc because the method ist const !
//     if not, one gets a warning like
//       warning: conversion from `const CTBvectorDsc<int>' 
//                to `CTBvectorDsc<int> &' discards const
//     for the return statement !

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

template <class T>
const CTBvectorDsc<T>& CTBvectorDsc<T>::operator=(
    const CTBvectorDsc<T>& rhs) const
{
  return operator=((const CTBvectorCDsc<T>) rhs);
}

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

template <class T>
const CTBvectorDsc<T>& CTBvectorDsc<T>::operator=(
    const CTBvectorCDsc<T>& rhs) const
{
  CTBint i_size = CTBmin(mi_size,rhs.Size());
  T*       po   = mp_data;
  const T* p1   = rhs.Data();
  CTBint   i_so = mi_stride;
  CTBint   i_s1 = rhs.Stride();

#ifdef CTB__ConformityCheck
  if (mi_size != rhs.Size())
    throw CTBexceptionConformity(mi_size,rhs.Size(),
                                 "CTBvectorDsc::operator=(CTBvectorDsc&)");
#endif

  for (CTBint i = 0; i < i_size; i++) {
    *po = *p1;
    po += i_so;
    p1 += i_s1;
  }
  return *this;
}

// Note:
//  1. a declaration of operator=(const CTBvectorCDsc<T>& rhs) alone does not
//     work because a Dsc is *not* converted automatically to a CDsc in the
//     resolution of an assignment. So one has to explicitely declare two
//     assignment operators, one for Dsc and one for CDsc.

---