objectar.hpp

// objectar.hpp
// $Id: objectar.hpp,v 1.8 2007/10/23 13:50:45 guser1 Exp $
//-----------------------------------------------------------------------
#ifndef objectarH
#define objectarH

#include <deque>
#include <vector>
#include <cassert>

using namespace std;

/*************************************************************
 * Dynamic Array of any elements
 *************************************************************/
template <class AnyType>
class objects_ar
{
private:

  std::vector<AnyType> m_vData;

public:
  
  objects_ar () {};
  ~objects_ar() { clean();};
  
  AnyType&  fetch (unsigned i)                      { assert(i < m_vData.size()); return m_vData[i]; };
  AnyType   get (unsigned i) const                  { assert(i < m_vData.size()); return m_vData[i]; };

  void          insert (unsigned i, const AnyType val)  { m_vData.insert(m_vData.begin() + i, val); };
  void          remove (unsigned i)                     {
    assert(i >=0 && i < m_vData.size());
    m_vData.erase(m_vData.begin()+i);
  };
  void          exchange (unsigned i, unsigned  j)      {
    assert(i >=0 && i < m_vData.size() && j >=0 && j < m_vData.size());
    AnyType tmp=m_vData[i]; m_vData[i]=m_vData[j]; m_vData[j]=tmp;
  };


  void          addh(const AnyType& val)                { m_vData.push_back(val); };
  void          addhn(unsigned n)                       { m_vData.resize(m_vData.size()+n); };
  
  void          clean()                                 { m_vData.clear(); }
  int           count() const                           { return m_vData.size(); }
  
  AnyType&  operator[] (unsigned i)                 { return fetch(i); };
  AnyType   operator() (unsigned i) const           { return get(i); };
  
  std::vector<AnyType>& get_data()                      { return m_vData;}
};


class double_ar : public objects_ar<double> {};
class float_ar : public objects_ar<float> {};
class int_ar : public objects_ar<int> {};

class bool_ar
{
private:

  std::deque<bool> m_vData;

public:

  bool_ar () {};
  ~bool_ar() {};
  
  bool&     fetch (unsigned i)                      { assert(i < m_vData.size()); return m_vData[i]; };
  bool      get (unsigned i) const                  { assert(i < m_vData.size()); return m_vData[i]; };

  void          insert (unsigned i, bool val)           { m_vData.insert(m_vData.begin() + i, val); };
  void          addh(const bool& val)                   { m_vData.push_back(val); };
  void          addhn(unsigned n)                       { m_vData.resize(m_vData.size() + n); };

  void          clean()                                 { m_vData.clear(); }
  int           count() const                           { return m_vData.size(); }

  bool&     operator[] (unsigned i)                 { return fetch(i); };
  bool      operator() (unsigned i) const           { return get(i); };

  std::deque<bool>& get_data()                          { return m_vData;}
};

#endif