base_separator.hpp

// $Id: base_separator.hpp 21022 2011-07-11 11:45:03Z urij $

#ifndef __base_separator_hpp__
#define __base_separator_hpp__

#include <stdexcept>


template<typename T>
class AvgBaseSep {
public:

  AvgBaseSep(T* array, size_t size,  size_t bases);
  
  T*  get(size_t ndx, size_t& amount) const {   return mp_array + getOffset(ndx, amount);  }
  
  size_t    getOffset(size_t ndx, size_t& amount) const;

  size_t    size() const { return m_bases; }

 
private:
  T*              mp_array;      // begin of the array
  size_t          m_bases;       // amount of bases
  size_t          m_dev;         // number of first smaller base
  size_t          m_base_size;   // size of bigger base
};






//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//                              Template's realisation
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------

template<typename T>
AvgBaseSep<T>::AvgBaseSep(T* array, size_t size,  size_t bases) :
  mp_array(array), 
  m_bases(bases),
  m_dev(0),
  m_base_size(0) 
{
  if (!array || bases == 0 || bases > size)
    throw std::logic_error("AvgBaseSep's constructor: Failed because of: 1) pointer to array is null. "
               "2) amount of bases is equal to zero or more than size of array.");
  
  m_dev = size % bases;
  m_base_size = size/bases + bool(m_dev);
 
  if (m_base_size==0) 
    throw std::logic_error("AvgBaseSep's constructor: Empty base. (Specfied zero size for array?).");
};
  


template<typename T>
size_t AvgBaseSep<T>::getOffset(size_t ndx, size_t& amount) const
{
  amount = 0;
  
  // index out of range
  if (ndx >= m_bases)
    throw std::out_of_range("AvgBaseSep->getOffset: index out of range.");
  
  size_t offset = 0;
  if (m_dev && ndx >= m_dev) {
    offset =  m_dev*m_base_size + (ndx-m_dev)*(m_base_size-1);
    amount = m_base_size-1;
  }
  else {
    offset = ndx*m_base_size;
    amount = m_base_size;
  }
  
  return offset;
}


#endif // __base_separator_hpp__