ArrayPtr.hpp

Go to the documentation of this file.

 
#ifndef ARRAYPTR_HPP_
#define ARRAYPTR_HPP_
#include "ArrayPrs.hpp"
using namespace std;
 
template<typename T, typename K>
class ArrayPtr {
    
    ~ArrayPtr();
    ArrayPtr();
 
public:
 
    template <class M, class H>
    friend class DTGrid2D;
    template <class M, class H>
    friend class DTGrid3D;
    friend class DTGrid3Dex;
    template <class M, class H>
    friend class DTGrid1D;
 
    //typedef ArrayPrs<K>* newtype;
    void Set_Pointer_Array_Values(typename ArrayPrs <K>::PairArray *,K *,int, int);
    void Set_Pointer_Array_Values(T *,K *,int, int);
    void Reset_Set_Pointer_Array_Values(void);
 
private:
 
    int alloc_size1;
    int alloc_size2;
    
    typename ArrayPrs <K>::PairArray **PtrArray;
    typename ArrayPrs <K>::PairArray **PtrArray_Copy; 
 
    T ** PtrArrayReg;
    T ** PtrArrayReg_Copy; 
};
 
 
template<typename T, typename K>
ArrayPtr<T,K>::ArrayPtr(){
    alloc_size1 = 0;
    alloc_size2 = 0;
}
 
 
template<typename T, typename K>
ArrayPtr<T,K>::~ArrayPtr()
{
    /*if (alloc_size1 != 0){
        for (int i = 0; i < alloc_size1; i++){
            delete PtrArray[i];
        }
    }*/
    if (alloc_size1 != 0){
        delete[] PtrArray;
    }
    else{
        //delete PtrArray;
    }
    //delete PtrArray;
    //delete PtrArray_Copy;
    /*if (alloc_size2 != 0){
        for (int i = 0; i < alloc_size2; i++){
            delete PtrArrayReg[i];
        }
    }*/
    if (alloc_size2 != 0){
        delete[] PtrArrayReg;
    }
    else{
        //delete PtrArrayReg;
    }
    //delete PtrArrayReg_Copy;
}
 
 
template<typename T, typename K>
void ArrayPtr<T,K>::Set_Pointer_Array_Values(typename ArrayPrs <K>::PairArray *pair_array, K * PtArray, int I, int J){
 
    alloc_size1 = J;
    PtrArray = new (nothrow) typename ArrayPrs <K>::PairArray * [J];
 
    int count = J-1;
    for (;count>=0;count--)  {
 
        //PtrArray[count] = new (nothrow) typename ArrayPrs <K>::PairArray;
        PtrArray[count] = &(pair_array[PtArray[count]]);
    }
    PtrArray_Copy = PtrArray;
}
 
 
template<typename T, typename K>
void ArrayPtr<T,K>::Set_Pointer_Array_Values(T *pair_array, K * PtArray, int I, int J){
 
    alloc_size2 = J;
    PtrArrayReg = new (nothrow) T* [J];
 
    int count = J-1;
    for (;count>=0;count--)  {
 
        //PtrArrayReg[count] = new T;
        PtrArrayReg[count] = &(pair_array[PtArray[count]]);
    }
    PtrArrayReg_Copy = PtrArrayReg;
}
 
 
template<typename T, typename K>
void ArrayPtr<T,K>::Reset_Set_Pointer_Array_Values(void){
    PtrArray_Copy = PtrArray;
    PtrArrayReg_Copy = PtrArrayReg;
}
 
#endif /* ARRAYPTR_HPP_ */