---

DbVArray.h

Go to the documentation of this file.

//====================================================================
//      dbVarray implementation
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: Management of the open Db files
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 11/07/99| Initial version                              | MF
// +---------+----------------------------------------------+---------
//====================================================================
#ifndef DBCNV_DBVARRAY_H
#define DBCNV_DBVARRAY_H 1

// Framework include files
#include "GaudiDb/DbOOMs.h"
// STL include files
#include <vector>

// Forward declarations
template <class T> class dbIterator;
template <class T> class dbVarray;

template <class T> class dbIterator   {
  dbVarray<T>& m_buffer;
  long m_ptr;
public:
  dbIterator( const dbVarray<T>& arr )  : m_buffer(arr), m_ptr(0)   {
  }
  dbIterator( const dbIterator<T>& it ) : m_buffer(it.m_buffer), m_ptr(it.m_ptr) {
  }
  dbIterator& operator=(const dbIterator<T>& it);
  const T& get_element()  const;
  int next(T& ref);
  int not_done()    const;
  dbIterator& operator++()    {
    advance();
    return *this;
  }
  dbIterator& operator++(int)    {
    advance();
    return *this;
  }
  void advance()    {
    m_ptr++;
  }
  void reset()    {
    m_ptr = 0;
  }
};


template <class T> class dbVarray : private std::vector<T>  {
  typedef std::vector<T> _Base;
  // The following is NOT in the standard ??
  const T& elem(long i)  const  {
    return _Base::operator[](i);
  }
public:
  typedef _Base::iterator iterator;
  typedef _Base::const_iterator const_iterator;
  iterator begin()    {
    return _Base::begin();
  }
  const_iterator begin()  const  {
    return _Base::begin();
  }
  iterator end()    {
    return _Base::end();
  }
  const_iterator end()  const  {
    return _Base::end();
  }
  dbVarray() {
  }
  dbVarray(long siz) {
    resize(siz);
  }
  dbVarray(const dbVarray<T>& copy) {
    *this = copy;
  }
  virtual ~dbVarray() {
  }
  dbVarray& operator =(const dbVarray<T>& copy) {
    _Base::operator=(copy);
    return *this;
  }
  T& elem(long i)   {
    return _Base::operator[](i);
  }
  void resize(long length)    {
//    if ( length < (long)_Base::size() )   {
//      iterator i = begin();
//      for ( long count = 0; count < length; count++ ) i++;
//      erase(i, end());
//    }
//    else  {
//      for ( long count = _Base::size(); count < length; count++ )  {
//        _Base::push_back(T());
//      }
    _Base::resize(length);
//    }
  }
  char* increase(long length)   {
    _Base::resize(length+size());
    return (char*)&elem(0);
  }
  long cardinality()    const   {
    return size();
  }
  const T& retrieve_element_at(long which)    {
    return elem(i);
  }
  int is_empty()    const   {
    return size() == 0;
  }
  void remove_all()   {
    resize(0);
  }
  DbResult extend(const T& val)   {
    set(size(), val);
    return DbOOMs::DbSuccess;
  }
  void insert_element(const T& val)   {
    set(size(), val);
  }
  void replace_element_at(const T& val, long i)   {
    set(i, val);
  }
  void replace_element_at(const T& val, const dbIterator<T>& it)   {
    (*it) = val;
  }
  void set(long i, const T& arg)    {
    if ( size() < i+1 )   {
      resize(i+1);
    }
    elem(i) = arg;
  }
  T& operator[] (long i)    {
    return elem(i);
  }
  const T& operator[] (long i)  const  {
    return elem(i);
  }
  long size()   const   {
    return _Base::size();
  }
  long upper_bound()    const   {
    return size();
  }
  dbIterator<T> create_iterator()   const   {
    return dbIterator<T>(*this);
  }
};

//##############################################################################
// Inline code
//##############################################################################

template <class T> inline 
dbIterator<T>& dbIterator<T>::operator=(const dbIterator<T>& it)    {
  m_buffer = it.m_buffer;
  m_ptr = it.m_ptr;
  return *this;
}
template <class T> inline 
const T& dbIterator<T>::get_element()  const   {
  return m_buffer[m_ptr];
}
template <class T> inline 
int dbIterator<T>::next(T& ref)    {
  if ( not_done() )   {
    ref = (0==m_ptr) ? m_buffer.elem(0) : m_buffer.elem(++m_ptr);
    return 1;
  }
  return 0;
}
template <class T> inline 
int dbIterator<T>::not_done()    const   {
  return m_ptr < m_buffer.size()-1;
}
#endif  // DBCNV_DBVARRAY_H

---