CORE_SharedPointersList.h

Go to the documentation of this file.

#ifndef CORE_SharedPointersList_H
#define CORE_SharedPointersList_H

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

template <class  T>
class CORE_SharedPointersList : public CORE_Object {
    //ATTRIBUTES
    vector<boost::shared_ptr<T> > mVector; 
  
    //ASSOCIATION

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

    inline const boost::shared_ptr<T>& operator[](const tUIndex & i)  const { 
       
        ASSERT_IN(i<(mVector.size()));
        return mVector[i];
    }; 
    inline boost::shared_ptr<T>& operator[](const tUIndex & i) { 
      
        ASSERT_IN(i<mVector.size());
        return mVector[i];
    };
    inline const T& operator()(const tUIndex & i)  const { 
      
        ASSERT_IN(i<mVector.size());
        ASSERT_IN(mVector[i].get()!=null);
        return *mVector[i].get();
    }; 
    inline T& operator()(const tUIndex & i) { 
        ASSERT_IN(i<mVector.size());
        ASSERT_IN(mVector[i].get()!=null);
        return *mVector[i].get();
    };

    // New 
    static inline boost::shared_ptr<CORE_SharedPointersList<T> > New() {
        boost::shared_ptr<CORE_SharedPointersList<T> > p(new CORE_SharedPointersList<T>(),
                                                         CORE_Object::Delete());
        return p;
    }; 
    //COPY 
    template<class Q>
    void copy(const CORE_SharedPointersList<Q>& cpy);
  
    // SET 
    inline void setSize(const tUIndex& n) {
        mVector.resize(n);
    };
 
    tBoolean set(const tUIndex& i,boost::shared_ptr<T> obj);
    inline tBoolean set(const tUIndex& i,T& obj) {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        return set(i,p);
    };
    inline tBoolean set(const tUIndex & i,T* obj) {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        return set(i,p);
    };
  
    tBoolean insert(const tUIndex& i,boost::shared_ptr<T> obj); 

    inline tBoolean insert(const tUIndex& i,T* obj) {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        return insert(i,p);
    }; 
    inline tBoolean insert(const tUIndex& i,T& obj) {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        return insert(i,p);
    };
  
  
    void add(boost::shared_ptr<T> obj)  {
        mVector.push_back(obj);
    }; 
    void add(T& obj)  {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        mVector.push_back(p);
    }; 
    void add(T* obj)  {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        mVector.push_back(p);
    };  


 
  
    virtual void addInList(const boost::shared_ptr<T>& obj) {
        add(obj);
    };
  
    template<class Q>
    void merge(const CORE_SharedPointersList<Q>& array); 

  
    inline tBoolean remove(boost::shared_ptr<T> obj) {
        return remove(obj.get());
    }

    tBoolean remove(const T& obj); 
    inline tBoolean remove(const T* obj) {
        if (obj==null) return false;
        return remove(*obj);
    }
  
    tBoolean removeAtIndex(const tUIndex& i);
  
  
    inline tBoolean remove() {
        tUIndex n=size();
        if (n==0) return false;
        return remove(n-1);
    };
    inline tBoolean removeFirst() {
        if (mVector.size()==0) return false;
        mVector.erase(mVector.begin());
        return true;
    };
    inline tBoolean removeLast() {
        if (mVector.size()==0) return false;
        mVector.erase(mVector.begin()+size()-1);
        return true;
    };
    
    inline void clear(){
        mVector.clear();
    };

    // GET 
 
    inline T* getLastElement() {
        if (mVector.size()==0) return null;
        return mVector[mVector.size()-1].get();
    };  
    inline const T* getLastElement() const {
        if (mVector.size()==0) return null;
        return mVector[mVector.size()-1].get();
    };  
 
    inline const T* get(const tUIndex& i) const {
        if (i>=mVector.size()) return null;
        return mVector[i].get();
    }; 

    inline T* get(const tUIndex& i) {
        if (i>=mVector.size()) return null;
        return mVector[i].get();
    };
  
    inline tUIndex size() const {return mVector.size();};
  
    inline tUIndex getSize() const {return mVector.size();};
  
 
    inline tBoolean exists(boost::shared_ptr<T> obj) const {
        return exists(obj.get());
    }
    tBoolean exists(const T& obj) const; 

    tBoolean exists(const T* obj) const {
        if (obj==null) return false;
        return exists(*obj);
    }

 

    void getValues(vector<T*>& vs);
    void getValues(vector<const T*>& vs) const;
  
   
    // OTHERS


    void permute(const tUIndex& i,const tUIndex& j);
  
    void reverse();
  
    inline typename vector<boost::shared_ptr<T> >::const_iterator begin() const {
        return mVector.begin();
    };
    inline typename vector<boost::shared_ptr<T> >::iterator begin()  {
        return mVector.begin();
    };
   
    inline typename vector<boost::shared_ptr<T> >::const_iterator end() const {
        return mVector.end();
    };
    inline typename vector<boost::shared_ptr<T> >::iterator end()  {
        return mVector.end();
    };
   

  
};
#include "CORE_SharedPointersList.hpp"
#endif