CORE_PtrArray.h

#ifndef CORE_PtrArray_H
#define CORE_PtrArray_H
 
#include "CORE_Array.h"
 
//numerics function header
#include "functions_numeric.h"
 
 
template <typename T,class I>
class CORE_PtrArray : public CORE_Array<T,I> {
 
    
private:
  
    //values of the array
    T *mValues;
    //capacity of the array 
    tIndex mCapacity;
    //usefull size of the array
    tIndex mSize;
    //indicates if values is a shared pointer : if true the values is only deleted in the class where the mIsSharedValeus is false
    tBoolean mIsSharedValues;
 
    // CONSTRUCTORS
public:
    CORE_PtrArray()  {
        mValues=null;
        mCapacity=0;
        mSize=0;
        mIsSharedValues=false;
    }
 
   
    
    
    // DESTRUCTORS
    virtual ~CORE_PtrArray() {
        desallocate();
    }
    
    
private:
    
    
    
    
    //MEMORY
    //=====
public:
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=CORE_Array<T,I>::getContentsMemorySize();
        mem+=mCapacity*sizeof(T);
        return mem;
    }
    
    //allocation methods
    //===================
public:
    inline void setSize(const tIndex& n)   {
        if (n>=mCapacity) allocate(n,false);
        mSize=n;
    };
    inline  tIndex getSize()  const {
        return mSize;
    };
 
 
    inline void resize(const tIndex& n) {
        if (mSize!=n) allocate(n,true);
        mSize=n;
    }
   
    
    inline void fitToSize(tInteger size) {
        if (size!=mCapacity) {
            allocate(size,true);
        }
        mSize=size;
    }
    
private:
    
    inline void allocate(const tIndex& n,const tBoolean& areOldValuesCopied) {
        //nothink to do
        if (n==mCapacity) return;
        
         
        //allocate the new values
        T* newValues=newAllocation(n);
       
       
        if (areOldValuesCopied) {
            //copy the old values in indices [0,oldSize[ and set to 0 in [oldSize,n[
            tIndex oldSize=mSize;
            const T* oldValues=mValues;
            //number of old values to copy
            tIndex m=functions_numeric::min(oldSize,n);
            //copy a block of memory of size m 
            if (m>0) memcpy(newValues,oldValues,m*sizeof(T));
            //init to 0 al values in [m,n]
            if (n>m) memset(&newValues[m],0,(n-m)*sizeof(T));
        }
 
        //delete the old values
        desallocate();
 
        //update the class attributes
        mValues=newValues;
        mIsSharedValues=false;
        mCapacity=n;
        
    }
protected:
    inline void desallocate() {
        if ( !mIsSharedValues && (mValues!=null)) {
            deleteAllocation(mValues);
            if (mValues!=null) {
                throw CORE_Exception("core",
                                     "CORE_PtrArray::desallocate()",
                                     "impossible to desallocate the memory");
            }
            mIsSharedValues=false;
            mCapacity=0;
            mSize=0;
        }
    }
 
protected:
 
    virtual T* newAllocation(const tIndex &n) const {
        try {
            //allocate with an element more for iteration with pointer
            T* newValues=new T[n];
            if (newValues==null) {
                throw CORE_Exception("core",
                                     "CORE_PtrArray::allocate("+std::to_string(n)+")",
                                     "not enought memory for allocation");
            }
            return newValues;
        } catch(std::exception& e) {
            throw CORE_Exception("core",
                                 "CORE_PtrArray::allocate("+std::to_string(n)+")",
                                 "not enought memory for allocation");
        }
        
        return null;
    }
    
    virtual void deleteAllocation(T*& mem) const {
        if (mem!=null) delete[] mem;
        mem=null;
    }
    
   
    //accessor operators
    //====================
public:
    inline const T& operator[](const tIndex& i) const {
#ifdef DEBUG
        if (i>=mSize) {
            throw CORE_Exception("core",
                                 "CORE_PtrArray[]",
                                 "CORE_PtrArray["+std::to_string(i)+"] is out of bounds [0,"+std::to_string(mSize)+"[ for reading");
        }
#endif
        return mValues[i];
    };
    inline T& operator[](const tIndex& i)  {
#ifdef DEBUG
        if (i>=mSize) {
            throw CORE_Exception("core",
                                 "CORE_PtrArray[]",
                                 "CORE_PtrArray["+std::to_string(i)+"] is out of bounds [0,"+std::to_string(mSize)+"[ for writing ");
        }
#endif
        return  mValues[i];
    };
 
  
    //iterator accessor
    //=================
public:
    inline constexpr auto cbegin() const {
        return CORE_ConstantStrideIterator<T*,1>(mValues);
    }
    inline constexpr auto cend() const {
        return CORE_ConstantStrideIterator<T*,1>(mValues+mSize);
    }
    inline  auto begin() {
        return CORE_StrideIterator<T*,1>(mValues);
    }
    inline auto end()  {
        return CORE_StrideIterator<T*,1>(mValues+mSize);
    }
 
    inline  auto rbegin() {
        return CORE_StrideIterator<T*,-1>(mValues+mSize-1);
    }
    inline auto rend()  {
        return CORE_StringIterator<T*,-1>(mValues-1);
    }
 
    inline constexpr auto crbegin() const {
        return CORE_ConstantStrideIterator<T*,-1>(mValues+mSize-1);
    }
    inline constexpr auto crend() const {
        return CORE_ConstantStrideIterator<T*,-1>(mValues-1);
        
    }
 
    //accessor methods
    //================
public:
  
    
    inline const T* getValues() const {
        return mValues;
    }
    inline T* getValues() {
        return mValues;
    }
 
    
 
    
 
    //assignment operators
    //====================
    
 
    //copy methods
    //============
 
 
    //Initializer methods
    //==================
public:
    template<typename Q>
    inline tBoolean  setSharedValues(const tIndex& capacity,const tIndex& size,Q* values) {
        if (sizeof(T)!=sizeof(Q)) return false;
 
        desallocate();
        mValues=(T*) values;
        mSize=size;
        mCapacity=capacity;
        mIsSharedValues=true;
        return true;
    }
 
    
    template<typename Q>
    inline tBoolean  setSharedValues(const tIndex& capacity,Q* values) {
        return setSharedValues(capacity,capacity,values);
        
    }
    template<typename Q,class I1>
    inline tBoolean  setSharedValues(CORE_PtrArray<Q,I1>& array) {
        return setSharedValues(array.mCapacity,array.getSize(),array.getValues());
    }
    
    
    //compound assignement operator
    //=============================
    
 
    //transform methods
    //==================
  
 
 
    template<class I1>
    inline void swap(CORE_PtrArray<T,I1>& a)  {
        std::swap(mValues,a.mValues);
    }
    inline void swap(const tIndex& i,const tIndex& j)  {
        std::swap(mValues[i],mValues[j]);
    }
 
    
    //array algebric operators
    //==========================
 
 
    
    //Data consistency
    //=================
    
 
       
    
 
    //algebric methods
    //================
    
   
   
    
};
 
 
#endif