CORE_WeakPointersArray.h

Go to the documentation of this file.

#ifndef CORE_WeakPointersArray_H
#define CORE_WeakPointersArray_H

#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"

#include "CORE_Object.h"

template <class  T>
class CORE_WeakPointersArray : public CORE_Object {
    //ATTRIBUTES

    //size of the array 
    tUIndex mSize;
    //capacity of the array
    tUIndex mCapacity;
    //capacity factor
    tFlag mCapacityFactor;
    
    //weak pointer array
    boost::weak_ptr<T>  *mValues; 
    
    //ASSOCIATION

public:
  
    //CONSTRUCTORS
    CORE_WeakPointersArray(); 
    template<class Q>
    CORE_WeakPointersArray(const CORE_WeakPointersArray<Q>& cpy); 
    // DESTRUCTORS
  
public:
    virtual ~CORE_WeakPointersArray(); 
    // OPERATORS

    inline boost::shared_ptr<const T> operator[](const tUIndex & i)  const { 
        ASSERT_IN(i>=0);
        ASSERT_IN(i<mSize);
        boost::shared_ptr<const T> v=mValues[i].lock();
        if (v) return v;
        else { 
            boost::shared_ptr<const T> temp;
            return temp;
        }
    }; 
    inline boost::shared_ptr<T> operator[](const tUIndex & i) { 
        ASSERT_IN(i>=0);
        ASSERT_IN(i<mSize);
        boost::shared_ptr<T> v=mValues[i].lock();
        if (v) return v;
        else { 
            boost::shared_ptr<T> temp;
            return temp;
        }
    };
  
    inline const T& operator()(const  tUIndex & i)  const {
        boost::shared_ptr<T> p=(*this)[i];
        ASSERT_IN(p.get()!=null);
        return *(p.get());
    }; 
    inline T& operator()(const int & i) {
        boost::shared_ptr<T> p=(*this)[i];
        ASSERT_IN(p.get()!=null);
        return *(p.get());
    };
    
    // New 
    static inline boost::shared_ptr<CORE_WeakPointersArray<T> > New() {
        boost::shared_ptr<CORE_WeakPointersArray<T> > p(new CORE_WeakPointersArray<T>(),
                                                        CORE_Object::Delete());
        return p;
    }; 
    //COPY 
    template<class Q>
    void copy(const CORE_WeakPointersArray<Q>& cpy);
  
    // SET
public:
    void resize(const tUIndex & cap);

public:
    void fit();
    inline void clear(){
        mSize=0;
    };
    void setSize(const tUIndex& n) {
        if (mCapacity>=n) mSize=n;
        else {
            resize(n);
            mSize=n;
        }
    };
    inline void setCapacityFactor(const unsigned int& cap) {
        mCapacityFactor=cap;
    }
    
    void set(const tUIndex& i,boost::shared_ptr<T> obj);
   
  
    void insert(const tUIndex& i,boost::shared_ptr<T> obj); 

   
  
  
    void add(boost::shared_ptr<T> obj)  {
        setSize(mSize+1);
        boost::weak_ptr<T> wobj=obj;
        mValues[mSize-1]=wobj;
    }; 
    void add(T& obj)  {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        add(p);
    }; 
   

  
    tBoolean remove(boost::shared_ptr<T> obj)  {
        if (obj.get()==null) return false;
        return remove(obj.get());
    }; 

    tBoolean remove(const T& obj); 
    tBoolean remove(const T* obj); 
  
    tBoolean removeAtIndex(const tUIndex& i);
  
  
    inline tBoolean remove() {
        return remove(mSize-1);
    }; 
  

    // GET 
 
    inline boost::shared_ptr<T> getLastElement() {
        if (mSize==0) {
            boost::shared_ptr<T> p;
            return p;
        }
        boost::shared_ptr<T> obj=mValues[mSize-1].lock();
        if (obj) return obj;
        else {
            boost::shared_ptr<T> p;
            return p;
        }
        
    };  
  
 

    inline const T* get(const  tUIndex& i) const {
        ASSERT_IN(i<mSize);
        boost::shared_ptr<T> obj=mValues[i].lock();
        if (obj) return obj.get();
        else {
            return null;
        }
    };
    inline T* get(const  tUIndex& i) {
        ASSERT_IN(i<mSize);
        boost::shared_ptr<T> obj=mValues[i].lock();
        if (obj) return obj.get();
        else {
            return null;
        }
    };
  
 
  
    inline const tUIndex& getSize() const {
        return mSize;
    };
  
 
    tBoolean exists(boost::shared_ptr<T> obj) const {
        if (obj.get()==null) return false;
        return exist(obj.get());
    };
    tBoolean exists(const T& obj) const; 

    tBoolean exists(const T* obj) const;

 
  
    
    
    
};
#include "CORE_WeakPointersArray.hpp"
#endif