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; 
  
  int mIterator;
  
  //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[](int i)  const { 
    ASSERT_IN(i>-1);
    ASSERT_IN(i<((int)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[](int i) { 
    ASSERT_IN(i>-1);
    ASSERT_IN(i<((int)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(int i,const boost::shared_ptr<T>& obj);
  
  tBoolean insert(int 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); 

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

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

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

  // OTHERS


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

  inline void begin() {
    mIterator=0;
  };
  
  inline tBoolean hasNext() const {
    return (mIterator<mVector.size());
  };
  inline boost::shared_ptr<T> next() {
    boost::shared_ptr<T> ret=mVector[mIterator].lock();
    mIterator++;
    if (ret) return ret;
    else {
      boost::shared_ptr<T> p;
      return p;
    }
  };
};
#include "CORE_WeakPointersList.hpp"

#endif