CORE_WeakPointersList.h

Go to the documentation of this file.

#ifndef CORE_WeakPointersList_H
#define CORE_WeakPointersList_H

#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
#include "CORE_Vector.h"
#include "CORE_SharedPointersList.h"
template <class T>
class CORE_WeakPointersList  : public CORE_Object {

  
    //ATTRIBUTES
private:
    vector<boost::weak_ptr<T> > mVector; 
  
  
    //ASSOCIATION
  
public:
  
    //CONSTRUCTORS
    CORE_WeakPointersList();

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

    inline boost::shared_ptr<const T> operator[](const tUIndex& i)  const { 
        ASSERT_IN(i<mVector.size());
        boost::shared_ptr<const T> v=mVector[(int)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<mVector.size());
        boost::shared_ptr<T> v=mVector[(int)i].lock();
        if (v) return v;
        else { 
            boost::shared_ptr<T> temp;
            return temp;
        }
    };
    // New 
    static inline boost::shared_ptr<CORE_WeakPointersList<T> > New() {
        boost::shared_ptr<CORE_WeakPointersList<T> > p(new CORE_WeakPointersList<T>(),
                                                       CORE_Object::Delete());
        return p;
    }; 
  
    // COPY
    template<class Q>
    void copy(const CORE_WeakPointersList<Q>& cpy); 

    template<class Q>
    void copy(const CORE_SharedPointersList<Q>& cpy);
 
    // SET 
    inline void setSize(const int& n) {
        mVector.resize(n);
    };
 
    tBoolean set(const tUIndex& i,const boost::shared_ptr<T>& obj);
    
    tBoolean insert(const tUIndex& i,const boost::shared_ptr<T>& obj); 
  
  
    void add(const boost::shared_ptr<T>& obj) {
        boost::weak_ptr<T> wobj=obj;
        mVector.push_back(wobj);
    }; 
    void add(T& obj) { 
        boost::shared_ptr<T> p;
        obj.getSharedPointer(p);
        add(p);
   
    };
  
    virtual void addInList(const boost::shared_ptr<T>& obj) {
        add(obj);
    };
  
    template<class Q>
    void merge(const CORE_WeakPointersList<Q>& array); 

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

    tBoolean remove(const T& obj); 
    tBoolean remove(const T* obj) {
        if (obj!=null) return remove(*obj);
        return false;
    }
  
    tBoolean removeAtIndex(const tUIndex& i);
  
  
    inline tBoolean remove() {
        if (size()==0) return false;
        return remove(size()-1);
    }; 
    inline void clear(){
        setSize(0);
        mVector.clear();
    };

    // GET 
 
    inline boost::shared_ptr<T> getLastElement() {
        ASSERT_IN(mVector.size()>0);
        boost::shared_ptr<T> obj=mVector[mVector.size()-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<mVector.size());
        boost::shared_ptr<T> obj=mVector[i].lock();
        if (obj) return obj.get();
        else {
            return null;
        }
    }; 

    inline T* get(const tUIndex& i) {
        ASSERT_IN(i<mVector.size());
        boost::shared_ptr<T> obj=mVector[i].lock();
        if (obj) return obj.get();
        else {
            return null;
        }
    };
  
    inline tUIndex size() const {return mVector.size();};
  
    inline  tUIndex getSize() const {return mVector.size();};
  
 
    tBoolean exists(const 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);
    }

 
    inline CORE_SharedPointersList<T> toSharedVector() {
        CORE_SharedPointersList<T> ret;
        tUIndex i,n=getSize();
        for (i=0;i<n;i++) {
            ret.add(get(i));
        }
        return ret;
    };

    // OTHERS


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

#endif