series.h

Go to the documentation of this file.

// include guard
#ifndef AFF_SERIES_H_VERSION

#define AFF_SERIES_H_VERSION \
  "AFF_SERIES_H   V1.12"

#include <aff/lib/sharedheap.h>
#include <aff/lib/linearshape.h>
#include <aff/lib/seriesstepper.h>
#include <aff/lib/error.h>
#include <aff/lib/deepcopy.h>

namespace aff {

  template<class T>
    class ConstSeries: 
      private aff::LinearShape
    {
      public:
        typedef aff::ConstSharedHeap<T> Trepresentation;
        typedef aff::LinearShape Tshape;
        typedef Tshape::Tstepper Tstepper;
        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 ConstSeries<T> Tcontainer;
        typedef Tcontainer Tcontainer_of_const;
        typedef Tcontainer Tcoc;

        /*-----------------------------------------------------------------*/
        
        ConstSeries() { }
        ConstSeries(const Tshape& shape,
                    const Trepresentation& representation):
          Tshape(shape), Mrepresentation(representation) 
          { check_consistency(); }
        ConstSeries(const Trepresentation& representation):
          Tshape(0,representation.size()-1,0),
          Mrepresentation(representation) { }

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

        const T& operator()(const Tsubscript& i) const
        { return(Mrepresentation[this->Tshape::offset(i)]); }

        const T* pointer() const
        { return &this->operator()(this->first()); }

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

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

        using Tshape::first;
        using Tshape::last;
        using Tshape::size;
        using Tshape::setfirstindex;
        using Tshape::setlastindex;
        using Tshape::setindexrange;
        using Tshape::shift;

        Tcontainer copyout() const;

        const Trepresentation& representation() const
        { return (Mrepresentation); }
     
        const Tshape& shape() const
        { return(*this); }

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

        Trepresentation Mrepresentation;

    }; // class ConstSeries<T>

  /*======================================================================*/
  
  template<class T>
    class Series: public ConstSeries<T> {
      public:
        typedef Series<T> Tcontainer;
        typedef ConstSeries<T> Tbase;
        typedef Tbase Tcontainer_of_const;
        typedef aff::LinearShape Tshape;
        typedef Tbase Tcoc;
        typedef aff::SharedHeap<T> Trepresentation;
        typedef T Tvalue;
        typedef T* Tpointer;
        typedef T& Treference;
        typedef const T Tconst_value;
        typedef const T* Tconst_pointer;
        typedef const T& Tconst_reference;

        /*-----------------------------------------------------------------*/
        
        Series() { }
        Series(const Tsize& size)
        {
          Tshape newshape(0, size-1, 0);
          Mrepresentation=Trepresentation(newshape.memory_size());
          Tbase::operator=(Tbase(newshape, Mrepresentation)); 
        }
        Series(const Tsubscript& first, const Tsubscript& last)
        {
          Tshape newshape(first, last, 0);
          Mrepresentation=Trepresentation(newshape.memory_size());
          Tbase::operator=(Tbase(newshape, Mrepresentation)); 
        }
        Series(const Tshape& shape)
        {
          Tshape newshape(shape.first(), shape.last(), 0);
          Mrepresentation=Trepresentation(newshape.memory_size());
          this->Tbase::operator=(Tbase(newshape, Mrepresentation));
        }
        Series(const Tshape& shape,
               const Trepresentation& representation):
          Tbase(shape, representation), Mrepresentation(representation) 
        { }
        Series(const Trepresentation& representation, 
               const Tsubscript& shift=0)
        {
          Tshape newshape(shift, shift+representation.size()-1, 0);
          Mrepresentation=representation;
          Tbase::operator=(Tbase(newshape, Mrepresentation)); 
        }

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

        using Tbase::operator();
        using Tbase::shape;
      
        T& operator()(const Tsubscript& i) const
        { return(Mrepresentation[this->Tbase::offset(i)]); }

        T* pointer() const
        { return &this->operator()(this->first()); }
          
        Tcontainer& operator=(const T& value);

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

        Tcontainer copyout() const;
     
        const Trepresentation& representation() const
        { return (Mrepresentation); }

      private:
        Trepresentation Mrepresentation;

    }; // class series

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

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

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

  template<class T>
    Series<T>& Series<T>::operator=(const T& value)
    {
      for (Tsubscript i=this->first(); i<=this->last(); i++)
      { Mrepresentation[this->Tbase::offset(i)]=value; }
      return(*this);
    }

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

  template<class T>
    Series<T> Series<T>::copyout() const
    {
      Tcontainer copy(this->first(),this->last());
      copy.copyin(*this);
      return(copy);
    }

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

  template<class T>
    ConstSeries<T> ConstSeries<T>::copyout() const
    {
      // must use a writeable container as intermediate object
      Series<T> copy(this->first(),this->last());
      copy.copyin(*this);
      return(copy);
    }
}

#endif // AFF_SERIES_H_VERSION (includeguard)

/* ----- END OF series.h ----- */