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; 
    int mIterator;
  
    //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 int & i)  const { 
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        return mVector[(int)i];
    }; 
    inline boost::shared_ptr<T>& operator[](const int & i) { 
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        return mVector[(int)i];
    };
    inline const T& operator()(const int & i)  const { 
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        ASSERT_IN(mVector[(int)i].get()!=null);
        return *mVector[(int)i].get();
    }; 
    inline T& operator()(const int & i) { 
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        ASSERT_IN(mVector[(int)i].get()!=null);
        return *mVector[(int)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 int& n) {
        mVector.resize(n);
    };
 
    tBoolean set(const int& i,const boost::shared_ptr<T>& obj);
    inline tBoolean set(const int& i,T& obj) {
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        return set(i,p);
    };
    inline tBoolean set(const int & i,T* obj) {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        return set(i,p);
    };
  
    tBoolean insert(const int& i,boost::shared_ptr<T> obj); 

    inline tBoolean insert(const int & i,T* obj) {
        boost::shared_ptr<T> p;
        if (obj!=null) obj->getSharedPointer(p);
        return insert(i,p);
    }; 
    inline tBoolean insert(const int& 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); 

  
    tBoolean remove(const boost::shared_ptr<T>& obj); 

    tBoolean remove(const T& obj); 
    tBoolean remove(const T* obj); 
  
    tBoolean removeAtIndex(const int& i);
  
  
    inline tBoolean remove() {
        return remove(size()-1);
    }; 
    inline void clear(){
        setSize(0);
        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 int& i) const {
        if (i<0) return null;
        if (i>=((int)mVector.size())) return null;
        return mVector[i].get();
    }; 

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

    tBoolean exists(const T* obj) const;

 

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


    void permute(const int& i,const int&j);
  
    void reverse();
  

    inline void begin() {
        mIterator=0;
    };
  
    inline tBoolean hasNext() const {
        return ((int)mIterator<(int)mVector.size());
    };
    inline boost::shared_ptr<T> next() {
        boost::shared_ptr<T> ret=mVector[mIterator];
        mIterator++;
        return ret;
    }; 

  
};
#include "CORE_SharedPointersList.hpp"
#endif