array.h

Go to the documentation of this file.

// include guard
#ifndef AFF_ARRAY_H_VERSION

#define AFF_ARRAY_H_VERSION \
  "AFF_ARRAY_H   V1.2"

#include <aff/lib/sharedheap.h>
#include <aff/lib/strided.h>
#include <aff/lib/stridedstepper.h>
#include <aff/lib/deepcopy.h>
#include <aff/lib/error.h>

/*======================================================================*/
// declaration part
// ===============

namespace aff {

  // forward declaration
  template<class T> class Array;

  template<class T>
    class ConstArray:
      private aff::Strided
    {
      public:
        typedef aff::ConstSharedHeap<T> Trepresentation;
        typedef aff::Strided Tshape;
        typedef Tshape::Tstepper Tstepper;
        typedef Tshape::TIndexVec TIndexVec;
        typedef T Tvalue;
        typedef T* Tpointer;
        typedef T& Treference;
        typedef const T Tconst_value;
        typedef const T* Tconst_pointer;
        typedef const T& Tconst_reference;
        typedef ConstArray<T> Tcontainer;
        typedef Tcontainer Tcontainer_of_const;
        typedef Tcontainer Tcoc;

        /*-----------------------------------------------------------------*/
        
        ConstArray() { }
        ConstArray(const Tshape& shape, 
                   const Trepresentation& representation):
          Tshape(shape), Mrepresentation(representation)
          { check_consistency(); }

        /*-----------------------------------------------------------------*/
      
        const T& operator()(const TIndexVec& index) const
        { return(Mrepresentation[offset(index)]); }
        const T& operator()(const Tsubscript& i0) const
        { return(Mrepresentation[offset(i0)]); }
        const T& operator()(const Tsubscript& i0,
                            const Tsubscript& i1) const
        { return(Mrepresentation[offset(i0, i1)]); }
        const T& operator()(const Tsubscript& i0,
                            const Tsubscript& i1,
                            const Tsubscript& i2) const
        { return(Mrepresentation[offset(i0, i1, i2)]); }
        const T& operator()(const Tsubscript& i0,
                            const Tsubscript& i1,
                            const Tsubscript& i2,
                            const Tsubscript& i3) const
        { return(Mrepresentation[offset(i0, i1, i2, i3)]); }

        /*-----------------------------------------------------------------*/

        const Tsubscript& f(const Tsubscript& i) const
        { return(this->Tshape::first(i)); }
        const Tsubscript& l(const Tsubscript& i) const
        { return(this->Tshape::last(i)); }

        Array<T> copyout() const;
      

        using Tshape::first;
        using Tshape::last;
        using Tshape::size;
     
        const Tshape& shape() const { return(*this); }
     
        Tshape& shape() { return(*this); }
     
        const Trepresentation& representation() const
        { return (Mrepresentation); }

      protected:
        using Tshape::offset;
          
      private:
        void check_consistency() const;
        
        Trepresentation Mrepresentation;

    }; // class ConstArray

  /*======================================================================*/

  template<class T>
    class Array:
      public ConstArray<T>
    {
      public:
        typedef Array<T> Tcontainer;
        typedef aff::ConstArray<T> Tbase;
        typedef Tbase Tcontainer_of_const;
        typedef Tbase Tcoc;
        typedef aff::SharedHeap<T> Trepresentation;
        typedef aff::Strided Tshape;
        typedef Tshape::TIndexVec TIndexVec;
        typedef T Tvalue;
        typedef T* Tpointer;
        typedef T& Treference;
        typedef const T Tconst_value;
        typedef const T* Tconst_pointer;
        typedef const T& Tconst_reference;

        /*-----------------------------------------------------------------*/
        
        Array() { }
        Array(const Tshape& shape, 
              const Trepresentation& representation):
          Tbase(shape, representation),
          Mrepresentation(representation) { }
        explicit Array(const Tshape& shape)
          { 
            Tshape newshape(shape.first(), shape.last());
            Mrepresentation=Trepresentation(newshape.memory_size());
            this->Tbase::operator=(Tbase(newshape, Mrepresentation));
          }
        explicit Array(const Tsize& s0, const Tsize& s1=1, 
                       const Tsize& s2=1, const Tsize& s3=1)
          { 
            Tshape newshape(s0, s1, s2, s3);
            Mrepresentation=Trepresentation(newshape.memory_size());
            this->Tbase::operator=(Tbase(newshape, Mrepresentation));
          }

        /*-----------------------------------------------------------------*/
      

        using Tbase::operator();
        using Tbase::shape;
        using Tbase::copyout;

        template<class C>
          Array& copyin(const C& a)
          {
            aff::deepcopy(a, *this);
            return(*this);
          }
     
        const Trepresentation& representation() const
        { return (Mrepresentation); }

        /*-----------------------------------------------------------------*/
          
        Tcontainer& operator=(const T& value);

        /*-----------------------------------------------------------------*/

        T& operator()(const TIndexVec& index) const
        { return(Mrepresentation[this->Tbase::offset(index)]); }
        T& operator()(const Tsubscript& i0) const
        { return(Mrepresentation[this->Tbase::offset(i0)]); }
        T& operator()(const Tsubscript& i0,
                      const Tsubscript& i1) const
        { return(Mrepresentation[this->Tbase::offset(i0, i1)]); }
        T& operator()(const Tsubscript& i0,
                      const Tsubscript& i1,
                      const Tsubscript& i2) const
        { return(Mrepresentation[this->Tbase::offset(i0, i1, i2)]); }
        T& operator()(const Tsubscript& i0,
                      const Tsubscript& i1,
                      const Tsubscript& i2,
                      const Tsubscript& i3) const
        { return(Mrepresentation[this->Tbase::offset(i0, i1, i2, i3)]); }

      private:
        Trepresentation Mrepresentation;

    }; // class Array

/*----------------------------------------------------------------------*/

} // namespace aff

/*======================================================================*/
// definition part
// ===============

namespace aff {

/*----------------------------------------------------------------------*/

  template<class T>
    void ConstArray<T>::check_consistency() const
    {
      AFF_assert((this->Tshape::first_offset()>=0),
                 "ERROR (ConstArray): invalid shape");
      AFF_assert((this->Tshape::last_offset()<
                  Tsubscript(Mrepresentation.size())),
              "ERROR (ConstArray): shape and representation are inconsistent");
    }

/*----------------------------------------------------------------------*/

  template<class T>
    Array<T> ConstArray<T>::copyout() const
    {
      aff::Array<T> copy(Tshape(this->first(),this->last()));
      copy.copyin(*this);
      return(copy);
    }

/*======================================================================*/

  template<class T>
    Array<T>& Array<T>::operator=(const T& value)
    {
      Tshape::Tstepper st(this->shape());
      for(st.tofirst(); st.valid(); st.incr())
      { Mrepresentation[st.current()]=value; } 
      return(*this);
    }

} // namespace aff

#endif // AFF_ARRAY_H_VERSION (includeguard)

/* ----- END OF array.h ----- */