---

SimpleArray.H

Go to the documentation of this file.

#ifndef SIMPLEARRAY_H
#define SIMPLEARRAY_H

#include <string>
#include <cassert>
#include <iostream>
#include <Vector.H>
#include <arglst.H>
#include <Exception.H>

using namespace std;

namespace xchen 
{
  template<typename T, int dims>
  class SimpleArrayIterator;
  
  template<typename T, int dims>
  class SimpleArray
  {
      typedef SimpleArray<T, dims-1> SubArrayType;
      typedef SimpleArray<T, dims+1> SuperArrayType;
      friend class SuperArrayType;
      friend class SimpleArrayIterator<T, dims+1>;
      template <typename t1, typename t2> friend class vector;

      vector< SubArrayType > data;
      int idx_bgn;
      
  public:
      typedef SimpleArrayIterator<T,dims> iterator;

      SimpleArray(int sz, ...);                                           
      SimpleArray(int* sz);                                               
      ListAssignmentCheckSzRt<T, iterator> operator=(T const& x);         

      void SetIndexStartAt(int arg1, ...)                                 { int bgn[dims]; get_reverse_ints_va(bgn,dims); set_idx_bgn(bgn); }
      int GetIndexStart() const                                           { return idx_bgn; }
      int GetSize() const                                                 { return data.size(); }
      
      SubArrayType& operator[](int i)                                     { throwError(i); return data[i-idx_bgn]; }
      T& operator[](Vector<int, dims>const& i)                            { throwError(i[dims-1]); return (*this)[i[dims-1]][Vector<int, dims-1>(i)]; }
      iterator Iterate()                                                  { return iterator(data); }
  private:
      SimpleArray() : idx_bgn(0)                                          { }
      void throwError(int idx) const;

      void set_idx_bgn(int bgn[dims])                                      // doing recursively.
      { 
        idx_bgn = bgn[dims-1];
        for(typename vector< SubArrayType >::iterator itr = data.begin(); itr != data.end(); ++itr)
        {
          itr->set_idx_bgn(bgn);
        }
      }
      void resize(int sz[dims])                                            // doing recursively.
      { 
        data.resize(sz[dims-1]);  
        for(typename vector< SubArrayType >::iterator itr = data.begin(); itr != data.end(); ++itr)
        {
          itr->resize(sz);
        }
      }
      int getTotalSz() { return data.size() * data.front().getTotalSz(); }

      friend ostream& operator<< <>(ostream& os, const SimpleArray&);
  };

  template<typename T>
  class SimpleArray<T,1>
  {
      friend class SimpleArray<T, 2>;
      friend class SimpleArrayIterator<T, 2>;
      template <typename t1, typename t2> friend class vector;
      
      vector<T> data;
      int idx_bgn;
      
  public:
      SimpleArray(int sz) : idx_bgn(0)                 { data.resize(sz); }     

      ListAssignmentCheckSzRt<T, SimpleArrayIterator<T,1> > operator=(T const& x);         

      void SetIndexStartAt(int bgn)                    { idx_bgn = bgn;  }
      int GetIndexStart() const                        { return idx_bgn; }
      int GetSize() const                              { return data.size(); }

      T& operator[](int i)                             { throwError(i);  return data[i-idx_bgn]; } 
      T& operator[](Vector<int, 1>const& i)            { throwError(i[0]); return data[i[0]-idx_bgn]; } 

  private:
      SimpleArray() : idx_bgn(0)                       { }
      void throwError(int idx) const;
      void set_idx_bgn(int* bgn)                       { idx_bgn = bgn[0];      }
      void resize(int* sz)                             { data.resize(sz[0]); }
      int getTotalSz()                                 { return data.size(); }

      friend ostream& operator<< <>(ostream& os, const SimpleArray&);
  };


  template<typename T, int dims>
  class SimpleArrayIterator
  {
      friend class SimpleArray<T,dims>;
      friend class SimpleArrayIterator<T,dims+1>;
      
      typedef SimpleArray<T, dims-1> SubArrayType;
      typedef SimpleArrayIterator<T,dims-1> SubIterator;
      
      vector<SubArrayType>* data;
      bool pastend;
      typename vector<SubArrayType>::iterator itr;

      SubIterator rec_itr;
      
      SimpleArrayIterator(vector<SubArrayType>& d) : data(&d), itr(d.begin()), rec_itr(d.front().data), pastend(false) { SubIterator( itr->data ); }

  public:
      SimpleArrayIterator& operator++()   
      { 
        if((++rec_itr).PastEnd())
        {
          if( ++itr == data->end() )
            pastend = true;
          else
            rec_itr = SubIterator( itr->data );
        }
        return *this; 
      }
      bool PastEnd()                               { return pastend; }
      T& operator*()                               { return *rec_itr; }
  };
  

  template<typename T>
  class SimpleArrayIterator<T,1>
  {
      friend class SimpleArrayIterator<T,2>;

      template<typename t, int dims> friend class SimpleArray;
      
      vector<T>* data;
      bool pastend;
      typename vector<T>::iterator itr;

      SimpleArrayIterator(vector<T>& d) : data(&d), itr(d.begin()), pastend(false) { }

  public:
      SimpleArrayIterator& operator++()   
      { 
        if( ++itr == data->end() )
          pastend = true;
        return *this; 
      }
      bool PastEnd()                               { return pastend; }
      T& operator*()                               { return *itr; }
  };


  template<typename T, int dims>
  inline SimpleArray<T,dims>:: SimpleArray(int arg1, ...) : idx_bgn(0)
  {
    int sz[dims]; 
    get_reverse_ints_va(sz,dims); 
    resize(sz);
  }

  template<typename T, int dims>
  inline SimpleArray<T,dims>:: SimpleArray(int* sz) : idx_bgn(0) 
  {
    resize(sz);
  }

  template<typename T, int dims>
  inline ListAssignmentCheckSzRt<T, SimpleArrayIterator<T,dims> > SimpleArray<T,dims> :: operator=(T const& x)  
  {
    SimpleArrayIterator<T,dims> itr(data);
    *itr = x;
    return ListAssignmentCheckSzRt<T, SimpleArrayIterator<T,dims> >(++itr, getTotalSz()-1);
  }

  template<typename T>
  inline ListAssignmentCheckSzRt<T, SimpleArrayIterator<T,1> > SimpleArray<T,1> :: operator=(T const& x)  
  {
    SimpleArrayIterator<T,1> itr(data);
    *itr = x;
    return ListAssignmentCheckSzRt<T, SimpleArrayIterator<T,1> >(++itr, getTotalSz()-1);
  }


  template<typename T, int dims>
  inline void SimpleArray<T,dims> :: throwError(int idx) const
  {
    int sz = data.size();
    
    if(idx < idx_bgn) 
    {
      throw ArrayError(Error::UNDER_FLOW, idx);
    }
    //    else if( idx >= (idx_bgn + (data.size())) )     THIS DOES NOT WORK!!!!!!!!!!!
    else if( idx >= idx_bgn + sz ) 
    {
      throw ArrayError(Error::OVER_FLOW, idx);
    }
    return;
  }

  template<typename T>
  inline void SimpleArray<T,1> ::  throwError(int idx) const
  {
    if(idx < idx_bgn) 
    {
      throw ArrayError(Error::UNDER_FLOW, idx);
    }
    else if(idx >= idx_bgn + data.size()) 
    {
      throw ArrayError(Error::OVER_FLOW, idx);
    }
  }


  template<typename T, int dims>
  ostream& operator<<(ostream& os, SimpleArray<T, dims> const & ar)
  {
    copy(ar.data.begin(), ar.data.end(), ostream_iterator< SimpleArray<T, dims-1> >(os, "\n"));
    return os;
  }
  

  template<typename T>
  ostream& operator<<(ostream& os, SimpleArray<T, 1> const & ar)
  {
    copy(ar.data.begin(), ar.data.end(), ostream_iterator<T>(os, " "));
    return os;
  }
  
  
}


#endif

---