CORE_VectorList.h

#ifndef CORE_VectorList_H
#define CORE_VectorList_H
 
//inherited class header
#include "CORE_List.h"
 
 
template <typename T,class I>
class CORE_VectorList : public CORE_List<T,tIndex,I> {
 
    
private:
 
    typedef CORE_VectorList<T,I> Self;
    
    std::vector<T> mValues;
   
    
    // CONSTRUCTORS
protected:
    CORE_VectorList() {
       
    }
    CORE_VectorList(const tIndex& n) : mValues(n){
       
    }
    
    // DESTRUCTORS
    virtual ~CORE_VectorList() {
    }
 
 
public:
 
    //memory method
    //=============
    
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+this->getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=CORE_List<T,tIndex,I>::getContentsMemorySize();
        mem+=mValues.capacity()*sizeof(T);
        return mem;
    }
 
     //allocation methods
    //===================
 
    inline void setSize(const tIndex& n)   {
        mValues.resize(n);
    };
    
    inline  tIndex getSize()  const {
        return mValues.size();
    }
 
    
    
    //accessor operators
    //====================
public:
    inline const T& operator[](const tIndex& i) const {
#ifdef DEBUG
        if (i>=mValues.size()) {
            throw CORE_Exception("core",
                                 "CORE_VectorList",
                                 "CORE_VectorList["+std::to_string(i)+"] is out of bounds [0,"+std::to_string(mValues.size())+"[ for reading");
        }
#endif
        return mValues[i];
    };
    inline T& operator[](const tIndex& i)  {
#ifdef DEBUG
        if (i>=mValues.size()) {
            throw CORE_Exception("core",
                                 "CORE_VectorList",
                                 "CORE_VectorList["+std::to_string(i)+"] is out of bounds [0,"+std::to_string(mValues.size())+"[ for writing");
        }
#endif
        return mValues[i];
    };
 
    
    
    
    //acessor iterators
    //==================
    inline constexpr auto cbegin() const {
        return mValues.cbegin();
    }
    inline constexpr auto cend() const {
        return mValues.cend();
    }
    inline  auto begin() {
        return mValues.begin();
    }
    inline auto end()  {
        return mValues.end();
    }
 
    inline  auto rbegin() {
        return mValues.rbegin();
    }
    inline auto rend()  {
        return mValues.rend();
    }
 
    inline constexpr auto crbegin() const {
        return mValues.crbegin();
    }
    inline constexpr auto crend() const {
        return mValues.cend();
    }
 
  
    
    
public:
 
    //NEW Instance
    //============
    
   
    
   
    //allocation methods
    //===================
 
  
 
    //assignment operators
    //====================
 
    
    
    //copy methods
    //============
    
    inline void copy(const Self& cpy) {
        const Self* selfCpy=dynamic_cast<const Self*>(&cpy);
        if (selfCpy!=null) {
            copy(*selfCpy);
        } else {
            copy(cpy.getSize(),cpy.getValues());
        }
    }
   
    template<typename Q,class I1>
    inline void copy(Self&& cpy) {
        const Self *selfCpy=dynamic_cast<const Self*>(&cpy);
        if (selfCpy!=null) {
            copy(*selfCpy);
        } else {
            copy(cpy.size(),cpy.getValues());
        }
    }
    
    
    inline void copy(const std::initializer_list<T>& vs) {
        Copy(vs,mValues);
    }
  
    inline void copy(std::initializer_list<T>&& vs) {
        Copy(vs,mValues);
    }
 
 
    
    
    inline static void Copy(const std::valarray<T>& X,std::vector<T>& R) {
        Copy(X.size(),*X[0],R);
    }
 
    
    inline static void Copy(const std::initializer_list<T>& X,std::vector<T>& R) {
        R=X;
    } 
    inline static void Copy(std::initializer_list<T>&& X,std::vector<T>& R) {
        R=X;
    }
    
   
    template<class Q>
    inline static void Copy(const std::vector<Q>& X,std::vector<T>& R) {
        if (R.size()!=X.size()) R.resize(X.size());
        //copy the values
        auto iX=X.cbegin() ;//begin iterator of This Values
        for(auto &Ri : R) {
            Ri=(*iX);
            iX++;
        }
    }
    
    inline static void Copy(const std::vector<T>& X,std::vector<T>& R) {
        R=X;
    }
    
    template<typename Q>
    inline static void Copy(const tIndex& n,const Q* X,std::vector<T>& R) {
        if (R.size()!=n) R.resize(n);
        //copy the values
        const Q *iX=X;//begin iterator of This Values
        for(auto &Ri : R) {
            Ri=(*iX);
            iX++;
        }
    }
    
    
    
    //initializers methods
    //====================
    
 
    
    //accessor methods
    //===================
 
    inline std::vector<T>& getValues() {
        return mValues;
    }
   
    inline const std::vector<T>& getValues() const {
        return mValues;
    }
   
    
   
public:
 
    
    //Data consistency
    //=================
    
    inline tString getDataTypeName() const {
        return functions_type::getTypeName<T>();
    }
    
    //transformation methods
    //=======================
   
  
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F) {
        std::transform(this->cbegin(),this->cend(),this->begin(),F);
    }
    
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                          const Self& X) {
        this->setSize(X.getSize());
        std::transform(X.cbegin(),X.cend(),
                       this->begin(),F);
    }
   
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                      const Self& X,
                      const Self& Y) {
        if (X.getSize()!=Y.getSize())
            throw CORE_Exception("core",
                                 "CORE_VectorList::Transform(F,X,Y,R)",
                                 "X ("+std::to_string(X.getSize())+") & Y ("+std::to_string(Y.getSize())+") have not same size");
        this->setSize(X.getSize());
        
        std::transform(X.cbegin(),X.cend(),
                       Y.cbegin(),
                       this->begin(),F);
    }
    
 
    
    inline void directionalSort(const tUChar& order) {
        switch(order) {
        case 'i':
            std::sort(this->begin(),this->end(),std::less<tString>());
            break;
        case 'd':
            std::sort(this->begin(),this->end(),std::greater<tString>());
            break;
        }
        
    }
    
 
   
 
    //string representation
    //=====================
    
   
};
 
 
#endif