CORE_Collection.h

#ifndef CORE_Collection_H
#define CORE_Collection_H
 
//inherited class header
#include "CORE_Object.h"
 
//smart pointer
#include "shared_pointer.h"
 
//vector header
#include <vector>
 
//map header
#include <map>
 
//val array header
#include <valarray>
 
 
//array header
#include <array>
 
template<typename T, class I>
class CORE_Collection : public CORE_Object {
 
    
private:
    //attributes
    //=========
 
    //associations
    //============
   
    
    // CONSTRUCTORS
    //=============
protected:
    CORE_Collection() {
       
    }
   
   
    
    // DESTRUCTORS
    virtual ~CORE_Collection() {
    }
 
 
    //memory method
    //=============
public:
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
  
    //allocation methods
    //===================
public:
   
 
    
    inline void setSize(const tIndex& n)   {
        static_cast<I*>(this)->setSize(n);
    };
    
    inline  tIndex getSize()  const {
        return static_cast<const I*>(this)->getSize();
    }
 
    inline void resize(const tIndex& n) {
        return static_cast<I*>(this)->resize(n);
    }
    //accessor operators
    //====================
public:
    inline const T& operator[](const tIndex& i) const {
        return (*static_cast<const I*>(this))[i];
    };
    inline T& operator[](const tIndex& i)  {
        return (*static_cast<I*>(this))[i];
    };
 
  
    //accessor iterator
    //==================
public:
    inline constexpr auto cbegin() const {
        return static_cast<const I*>(this)->cbegin();
    }
    inline constexpr auto cend() const {
        return static_cast<const I*>(this)->cend();
    }
    inline  auto begin() {
        return static_cast<I*>(this)->begin();
    }
    inline auto end()  {
        return static_cast<I*>(this)->end();
    }
 
    inline  auto rbegin() {
        return static_cast<I*>(this)->rbegin();
    }
    inline auto rend()  {
        return static_cast<I*>(this)->rend();
    }
 
    inline constexpr auto crbegin() const {
         return static_cast<const I*>(this)->crbegin();
    }
    inline constexpr auto crend() const {
        return static_cast<const I*>(this)->crend();
    }
 
  
    
    //accessor methods
    //================
 
 
    
 
    //assignment operators
    //====================
 
  
public:
 
 
    
    //copy methods
    //============
 
    
    //Initializers methods
    //=====================
    
public:
    //assignement operators (+=,-=,*=,/=,^=...)
    //=========================================
 
    
    //transformation methods
    //=======================
    
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F) {
        static_cast<I*>(this)->transform(F);
    }
 
    
    
    
 
    //Data consistency methods
    //========================
    
    inline tString getDataTypeName() const {
        return functions_type::getTypeName<T>();
    }
    
 
    //algebric methods
    //================
 
    //ordonal methods
    //===============
    
    
    //string representation
    //=====================
    virtual tString toString() const  override {
        std::stringstream cstr;
        cstr<<CORE_Object::toString()<<":{ ";
        std::for_each(this->cbegin(),this->cend(),
                      [&cstr](const auto& Vi) {
                          cstr << Vi << ',';
                      });
        cstr.seekp(-1, std::ios_base::end);
        cstr<<"}\n";
        return cstr.str();
    }
    
};
 
 
#endif