slice.h

Go to the documentation of this file.

// include guard
#ifndef AFF_SLICE_H_VERSION

#define AFF_SLICE_H_VERSION \
  "AFF_SLICE_H   V1.4"

#include<aff/array.h>

namespace aff {
namespace util {

  template<class C>
    class Slice
    {
      public:
        typedef C Tarray;
        typedef C Tcontainer;
        typedef typename Tarray::Tconst_value Tconst_value;
        typedef typename Tarray::Tconst_reference Tconst_reference;
        typedef typename Tarray::Tconst_pointer Tconst_pointer;
        typedef typename Tarray::Tshape Tshape;
        typedef typename Tarray::Trepresentation Trepresentation;
        Slice(const Tarray& array)
        {
          // notice: a const Array does not return its representation
          // thus me create a local (non-const) copy
          // that's truely inefficient (copying the shape twice)
          Tarray copy=array;
          Mshape=copy.shape();
          Mrepresentation=copy.representation();
          Mdim=0;
        }
        Slice& operator()()
        { 
          ++Mdim;
          return(*this); 
        }
        Slice& operator()(const Tsubscript& index)
        { 
          this->check_dim();
          Mshape.collapse(Mdim, index);
          ++Mdim;
          return(*this); 
        }
        Slice& operator()(const Tdim& dim, const Tsubscript& index) 
        { 
          Mshape.collapse(dim, index);
          return(*this); 
        }
        Slice& operator=(Tconst_reference value)
        {
          typename Tshape::Tstepper st(Mshape);
          for(st.tofirst(); st.valid(); st.incr())
          { Mrepresentation[st.current()]=value; } 
          return(*this);
        }
        Tarray array() const
        { return(Tarray(Mshape,Mrepresentation)); }
        operator Tarray() const
        { return(Tarray(Mshape,Mrepresentation)); }
      private:
        void check_dim() const
        {
          AFF_assert((Mdim<Tshape::Mmax_dimen),
                     "ERROR (Slice): you use too many dimension-brackets!");
        }
        Tshape Mshape;
        Trepresentation Mrepresentation;
        Tdim Mdim;
    }; // class Slice

} // namespace util

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

template<class C>
inline
aff::util::Slice<C> slice(const C& c) 
{ return(aff::util::Slice<C>(c)); }

} // namespace aff

#endif // AFF_SLICE_H_VERSION (includeguard)

/* ----- END OF slice.h ----- */