CORE_WeakPointersArray.hpp

Go to the documentation of this file.

#ifndef CORE_WeakPointersArray_CPP
#define CORE_WeakPointersArray_CPP

#include "CORE_WeakPointersArray.h"
#include "CORE_Exception.h"

template<class T>
CORE_WeakPointersArray<T>::CORE_WeakPointersArray():CORE_Object() { 
    mSize=0;
    mCapacity=1;
    mCapacityFactor=1;
    mValues=new  boost::weak_ptr<T>[mCapacity];
}

template<class T>
template<class Q>
CORE_WeakPointersArray<T>::CORE_WeakPointersArray(const CORE_WeakPointersArray<Q>& cpy):CORE_Object() {
    copy(cpy);
}


template<class T>
CORE_WeakPointersArray<T>::~CORE_WeakPointersArray() {
    mSize=0;
    mCapacity=0;
    mCapacityFactor=0;
    if (mValues!=null) delete[] mValues;
}


template<class T>
template<class Q>
void CORE_WeakPointersArray<T>::copy(const CORE_WeakPointersArray<Q>& cpy) {
    tArrayIndex i,n=cpy.getSize();
    mCapacityFactor=1;
    setSize(n);
   
    for (i=0;i<n;i++) {
        mValues[i]=boost::dynamic_pointer_cast<T>(cpy[i]);
    }
    
}
template<class T>
void CORE_WeakPointersArray<T>::resize(const tArrayIndex& cap) {
    // no reallocation
    if (cap<mCapacity) return;
    //set capacity
    if (mCapacityFactor<=1) mCapacity=cap+1;
    else while (mCapacity<=cap) mCapacity*=mCapacityFactor;
    //reallocation
    boost::weak_ptr<T>  *newValues=null;
    try {
       newValues=new  boost::weak_ptr<T>[mCapacity];
    } catch (std::exception e) {
        cout << e.what()<<"\n";
        throw CORE_Exception("common/core",
                             "CORE_WeakPointersArray<T>::resize(cap)",
                             "not enought memory to allocate new array");
    }
    
    //copy the array
    if (mSize>0) {
        const boost::weak_ptr<T>  *cValues=&(*this)[0];
        for (tArrayIndex i=0;i<mSize;i++) {
            *newValues=boost::dynamic_pointer_cast<T>(*cValues);
            newValues++;
            cValues++;
        }
    }
    //delete old values
    if (mValues!=null) delete[] mValues;
    
    //make the pointer link
    mValues=newValues;
    
}
template<class T>
void CORE_WeakPointersArray<T>::fit() {
    // no reallocation
    if (mSize+1==mCapacity) return;
    //set capacity
    mCapacity=mSize+1;
    //reallocation
    boost::shared_ptr<T>  *newValues=null;
    try {
      newValues =new  boost::weak_ptr<T>[mCapacity];
    } catch (std::exception e) {
        cout << e.what()<<"\n";
        throw CORE_Exception("common/core","CORE_WeakPointersArray<T>::resize(cap)",
                           "not enought memory to allocate new array");
    }
    //copy
    if (mSize>0) {
        const boost::weak_ptr<T>  *cValues=&(*this)[0];
        for (tArrayIndex i=0;i<mSize;i++) {
            *newValues=boost::dynamic_pointer_cast<T>(*cValues);
            newValues++;
            cValues++;
        }
    }
    //delete old values
    if (mValues!=null) delete[] mValues;
    
    //make the pointer link
    mValues=newValues;
}



template<class T>
void CORE_WeakPointersArray<T>::set(const tArrayIndex & index,boost::shared_ptr<T> obj) { 
    if (index>=mSize) {
        setSize(index+1);
    }
    mValues[index]=obj;
}

template<class T>
void  CORE_WeakPointersArray<T>::insert(const tArrayIndex& index,boost::shared_ptr<T> obj) {
    if (index>=mSize) add(obj);
    else {
        setSize(mSize+1);
        boost::weak_ptr<T>  *pValues=&(*this)[mSize];
        const boost::weak_ptr<T>  *cValues=null;
        if (mSize>1) {
            cValues=&(*this)[mSize-1];
            for (tArrayIndex i=mSize;i>index;i--) {
                *pValues=*cValues;
                pValues--;
                cValues--;
            }
        }
        *pValues=obj;
    }
}

template<class T>
tBoolean CORE_WeakPointersArray<T>::remove(const T* obj) {
    
    tBoolean exists=false;
    if (mSize==0) return false;
    tArrayIndex i=mSize-1;
    boost::weak_ptr<T>  *pValues=&(*this)[i];
    if ((*pValues).lock().get()==obj) removeAtIndex(i);
    while (i>0) {
        i--;
        pValues--;
        if ((*pValues).lock().get()==obj) {
            removeAtIndex(i);
            exists=true;
        }
    }
    return exists;
}

template<class T>
tBoolean CORE_WeakPointersArray<T>::remove(const T& obj) {
    return remove(&obj);
}


template<class T>
tBoolean CORE_WeakPointersArray<T>::removeAtIndex(const tArrayIndex& i) {
    
    if ((i<0) || (i>=mSize)) return false;
    
    
    boost::weak_ptr<T>  *pValues=&(*this)[i]; 
    tArrayIndex k=i+1;
    const boost::weak_ptr<T>  *cValues=null;
    if (k<mSize) {
        
        cValues=&(*this)[k];
        while (k<mSize) {
            *pValues=*cValues;
            pValues++;
            cValues++;
            k++;
        }
    }
    mSize--;
    return true;
}



template<class T>
tBoolean CORE_WeakPointersArray<T>::exists(const T& obj) const {
    return exists(&obj);
};
template<class T>
tBoolean CORE_WeakPointersArray<T>::exists(const T* obj) const {
    if (mSize==0) return false;
    const boost::weak_ptr<T>  *pValues=&(*this)[0]; 
    for (tArrayIndex i=0;i<mSize;i++) {
        if ((*pValues).lock().get()==obj) return true;
        pValues++;
    }
    return false;
}


#endif