tarray1.hxx

Go to the documentation of this file.

#ifndef NUMCXX_TARRAY1_H
#define NUMCXX_TARRAY1_H
#include <vector>
#include "tarray.hxx"

namespace numcxx
{

  template<typename T> class TArray1: public TArray<T>, public ExpressionBase
  {
  public:
    using TArray<T>::operator[];
    using TArray<T>::size;
    using TArray<T>::resize;
    using TArray<T>::operator=;


        

    TArray1(index n):TArray<T>(n){};

    TArray1(const std::initializer_list<T> &il ):TArray<T>(il){};

    TArray1(index n0, T*data, std::function<void(T*p)> deleter):TArray<T>(n0,data,deleter){};

    TArray1(index n0, T*data, std::shared_ptr<void> datamanager):TArray<T>(n0,data,datamanager){}; 


    TArray1(std::shared_ptr<std::vector<T>> v):TArray<T>(v->size(),v->data(),v){};

    static std::shared_ptr<TArray1 <T> > create(index n1) { return std::make_shared<TArray1 <T> >(n1);}


    static std::shared_ptr<TArray1 <T> > create(const std::initializer_list<T> il){return std::make_shared<TArray1 <T> >(il);}

    std::shared_ptr<TArray1 <T> > copy() const {return std::make_shared<TArray1 <T>>(*this); }


    std::shared_ptr<TArray1 <T> > clone() const     {  return create(size()); }



    TArray1<T>&  operator=(const TArray1<T> &expr) {return static_cast<TArray1<T>&>(assign(*this,expr));}

    TArray1(const TArray1<T>& A):TArray1<T>(A.shape(0)){assign(*this,A);}

    TArray1(TArray1<T> && A):TArray1<T>(A.shape(0), A._data, [](T*p){;})
    {
      TArray<T>::_deleter=std::move(A._deleter);
      TArray<T>::_datamanager=A._datamanager;  
      A._nullify();
    }

    TArray1<T>& operator=(TArray1<T> && A){
      if ( TArray<T>::_datamanager==nullptr)   TArray<T>::_deleter(_data);
      TArray<T>::_setshape(A.shape(0));
      TArray<T>::_data=A._data; 
      TArray<T>::_deleter=A._deleter;
      TArray<T>::_datamanager=A._datamanager;  
      A._nullify();
      return *this;
    }
        
    template <typename EXPR, typename= typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>
    TArray1(const EXPR& A):TArray1<T>(A.size()){assign(*this,A);}

    T item(index i0) const  { return _data[_idx(i0)];};


    void itemset(index i0, T x) { _data[_idx(i0)]=x;};


    T __getitem__(index i0) const  { return _data[_idx(i0)]; };


    void __setitem__(index i0,T x)  { _data[_idx(i0)]=x; };

    
    bool is_matrix()  {return false;};

    TArray1():TArray<T>(){};

  private:
    using TArray<T>::_data;
    using TArray<T>::_idx;
       
  };
}
#endif