CORE_Array.hpp

Go to the documentation of this file.

#ifndef CORE_Array_HPP
#define CORE_Array_HPP

#include <CORE_Array.h>
#include <vector>
#include "CORE_Integer.h"
#include "CORE_String.h"
#include "CORE_Vector.h"
#include "CORE_Exception.h"

using namespace std;


template<class T>
template<class Q>
void CORE_Array<T>::copy(const CORE_Array<Q>& f) {
    tUIndex k,n=f.getSize();
    
    if (n==0) {
        desallocate();
        return;
    }
    
    //allocate the vector
    if (n>mCapacity) {
        allocate(n);
    }

    //set the size
    mSize=n;
    
    //copy the vector
    const Q* pf=&f[0];
    T* vs=mValues;

    if (sizeof(T)==sizeof(Q)) {
        //copy a block of memory
        memcpy(vs,pf,sizeof(T)*n);
    } else {
        //copy each value
        for (k=0;k<n;k++) {
            *vs=*pf;
            vs++;
            pf++;
            
        }
    }
}


template<class T>
void CORE_Array<T>::desallocate() {
    if ( mIsPrivateAllocated && (mValues!=null)) {
        delete[] mValues;
        mValues=null;
        mIsPrivateAllocated=false;
        mCapacity=0;
        mSize=0;
        
    }
}

template<class T>
void CORE_Array<T>::allocate(const tUIndex& s) {
    //nothink to do
    if (s==mCapacity) return;

    //save the old size
    tUIndex oldSize=mSize;
    
    //allocate the new values
    T* newValues=null;
    try {
        //allocate with an element more for iteration with pointer
        newValues=new T[s+1];
    } catch(std::exception& e) {
        throw CORE_Exception("common/core",
                             "CORE_Array::allocate("+CORE_Integer::toString(s)+")",
                             "not enought memory for allocation");
    }
    if (newValues==null) {
        throw CORE_Exception("common/core",
                             "CORE_Array::allocate("+CORE_Integer::toString(s)+")",
                             "not enought memory for allocation");
    }
    
    //copy the old values
    T* p=newValues;
    const T* oldP=mValues;
    //m = min(mCapacity,s);
    tUIndex m=(mCapacity<s)?mCapacity:s;
    if (m>0) {
        //copy a block of memory
        memcpy(p,oldP,m*sizeof(T));
    }
   
    // for (tUIndex i=0;i<m;i++) {
    //     *p=*oldP;
    //     p++;
    //     oldP++;
    // }
    
    //reset to 0 the new values by block memory
    p+=m;
    memset(p,0,sizeof(T)*(s-m+1));
    
    // for (i=m;i<=s;i++) {
    //     *p=(T) 0;
    //     p++;
    // }
   
    
    //desallocate the values array: sze is reduced to 0
    desallocate();
    
    //set the new values
    mValues=newValues;
    mIsPrivateAllocated=true;
    mCapacity=s;
    //update the size 
    mSize=(oldSize>=mCapacity)?mCapacity:oldSize;
}




template<class T>
void CORE_Array<T>::fitToSize() {
    
    tUIndex n=getSize();
    if (mCapacity==n) return;
    allocate(n);
}


template<class T>
template<class Q>
void CORE_Array<T>::initArray(const tUIndex& p,const Q B[]) {
    
    //get the size of the field
    tUIndex n=getSize()/p;
    if (n==0) return;
    
    
    //set the value
    tUSInt d=0;
    tUIndex i;

    //get the first element of this
    T *vs=&(*this)[0];
   
    const Q* b=null;

    if (sizeof(T)==sizeof(Q)) {
        //copy by block
        i=0;
        while (i<n) {
            //copy the block B
            memcpy(vs,B,sizeof(T)*p);
            
            //next block
            vs+=p;
            i++;
            
        }
    } else {
        //make i loops on size p
        i=0;
        while (i<n) {
            b=&B[0];
            //loop on size p
            for (d=0;d<p;d++)  {
                *vs=(T) *b;
                b++;
                vs++;
            }
            i++;
        }
    }
}






template<class T>
template<class Q>
void CORE_Array<T>::initArray(const tUIndex& from,const tUIndex& to,const tUIndex& p,const tUSInt& inc,const Q B[]) {
   
    //get the size of the field
    tUIndex n=getSize();
    if (n==0) return;
    
    //for dimenson loop
    tUSInt d=0;
    
    //set the bounds
    if (to<n) n=to; 
    if (from>=n) return;
   
    tUIndex i=from;
    
    //get the value of This at from index
    T *vs=&(*this)[i];
    
    //ge the intial value of B
    const Q* b=&B[0];

    //index of element of b
    d=0;
    while (i<n) {//loop on i
        
        //the the This value to b
        *vs=(T)(*b);

        //next element i
        i++;
        
        //next value of this
        vs++;
        
        //index of next element of b
        d+=inc;
        //test if the end values of B is reached
        if (d>=p) {
            //end values of B is reached, go back to the first element
            d=0;
            b=&B[0];
        } else {
            //increment b
            b+=inc;
        }
    }
    
}


template<class T>
template<class Q>
void CORE_Array<T>::initArray(const tUIndex& from,const tUIndex& to,const Q& Bx,const Q& By,const Q& Bz) {
   
    //get the size of the field
    tUIndex n=getSize();
    if (n==0) return;
    
    //set the bounds
    if (to<n) n=to; 
    if (from>=n) return;
   
    tUIndex i=from;
    T *vs=&(*this)[i];

    n=(n-from)/3;
    while (i<n) {
        *vs=(T)Bx;
        vs++;
        *vs=(T)By;
        vs++;
        *vs=(T)Bz;
        vs++;
        i++;
    }
    
       
}


template<class T>
void CORE_Array<T>::initArray(const tUIndex& from,const tString& v) {
    tUIndex l=v.length();
    if (l==0) {
        clear();
    }
    if ((v[0]!='[') && (v[0]!='(')) return;
    SP::CORE_String str=CORE_String::New(v.substr(1,v.length()-2));
    str->tokenize(",");
    str->begin();
    tUIndex n=str->getTokensCount();
    tUIndex newDim=n+from; 
    // verify the capacity is sufficent
    if (newDim>mCapacity) allocate(newDim); 
  
    // set the size
    setSize(n+from);

    T value;
    T* values=&mValues[from];
    while (str->hasNextToken()) {
        //parse the value
        CORE_String::parse(str->nextToken(),value);
        //set it
        *values=value;
        //next iter
        values++;
    }
}


template<class T>
tString CORE_Array<T>::toString() const {
    tString ret="[";
    if (mSize>0) {
        const T *vs=&(*this)[0];
        for (tUIndex i=0;i<mSize-1;i++) {
            ret+=CORE_String::toString(*vs);
            ret+=",";
            vs++;
        }
        ret+=CORE_String::toString(*vs);
       
    }
    ret+="]";
    return ret;
}


#endif