CORE_SharedPointersArray.h

Go to the documentation of this file.

#ifndef CORE_SharedPointersArray_H
#define CORE_SharedPointersArray_H

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

#include "CORE_Object.h"

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

    //size of the array
    tArrayIndex mSize;

    //capacity of the array
    tArrayIndex mCapacity;

    //capacity factor for reallocation
    tFlag mCapacityFactor;
    
    //array of boost pointer
    boost::shared_ptr<T>  *mValues; 
    
    //ASSOCIATION

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

    inline const boost::shared_ptr<T>& operator[](const tArrayIndex & i)  const { 
        ASSERT_IN(i>=0);
        ASSERT_IN(i<mSize);
        return mValues[i];
    }; 
    inline boost::shared_ptr<T>& operator[](const tArrayIndex & i) { 
        ASSERT_IN(i>=0);
        ASSERT_IN(i<mSize);
        return mValues[i];
    };
    inline const T& operator()(const  tArrayIndex & i)  const {
        ASSERT_IN(i>=0);
        ASSERT_IN(i<mSize);
        ASSERT_IN(mValues[i].get()!=null);
        return *(mValues[i].get());
    }; 
    inline T& operator()(const int & i) {
        ASSERT_IN(i>=0);
        ASSERT_IN(i<mSize);
        ASSERT_IN(mValues[i].get()!=null);
        return *(mValues[i].get());
    };

    // New 
    static inline boost::shared_ptr<CORE_SharedPointersArray<T> > New() {
        boost::shared_ptr<CORE_SharedPointersArray<T> > p(new CORE_SharedPointersArray<T>(),
                                                          CORE_Object::Delete());
        return p;
    }; 
    //COPY 
    template<class Q>
    void copy(const CORE_SharedPointersArray<Q>& cpy);
  
    // SET
public:
    void resize(const tArrayIndex & cap);

public:
    void fit();
    inline void clear(){
        mSize=0;
    };
    void setSize(const tArrayIndex& n) {
        if (mCapacity>=n) mSize=n;
        else {
            resize(n);
            mSize=n;
        }
    };
    inline void setCapacityFactor(const tFlag& cap) {
        mCapacityFactor=cap;
    }
    
    void set(const tArrayIndex& i,boost::shared_ptr<T> obj);
    inline void set(const tArrayIndex& i,T& obj) {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        set(i,p);
    };
    inline void set(const tArrayIndex & i,T* obj) {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        set(i,p);
    };
  
    void insert(const tArrayIndex& i,boost::shared_ptr<T> obj); 

    inline void  insert(const tArrayIndex & i,T* obj) {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        insert(i,p);
    }; 
    inline void insert(const tArrayIndex& i,T& obj) {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        insert(i,p);
    };
  
  
    void add(boost::shared_ptr<T> obj)  {
        setSize(mSize+1);
        mValues[mSize-1]=obj;
    }; 
    void add(T& obj)  {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        add(p);
    }; 
    void add(T* obj)  {
        boost::shared_ptr<T> p;
        if (obj!=null) 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 tArrayIndex& i);
  
  
    inline tBoolean remove() {
        return remove(mSize-1);
    }; 
  

    // GET 
 
    inline T* getLastElement() {
        return (mSize==0)?null:mValues[mSize-1].get();
    };  
    inline const T* getLastElement() const {
        return (mSize==0)?null:mValues[mSize-1].get();
    };  
 
    inline const T* get(const tArrayIndex& i) const {
        return  ( (i<0) || (i>=mSize) ) ? null:mValues[i].get();
    }; 

    inline T* get(const tArrayIndex& i) {
        return  ((i<0) || (i>=mSize)) ? null:mValues[i].get();
    };
  
 
  
    inline const tArrayIndex& getSize() const {
        return mSize;
    };
  
 
    tBoolean exists(const T& obj) const; 

    tBoolean exists(const T* obj) const;

 
  
    
    
    
};
#include "CORE_SharedPointersArray.hpp"
#endif