CORE_SharedPointersMatrix.h

Go to the documentation of this file.

#ifndef CORE_SharedPointersMatrix_H
#define CORE_SharedPointersMatrix_H

#include "CORE_SharedPointersList.h"
template <class  T>
class CORE_SharedPointersMatrix : public CORE_Object {

    //ATTRIBUTES
    vector<CORE_SharedPointersList<T> > mVector; 
  
  
    //ASSOCIATION

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

    // NEW
    inline boost::shared_ptr<CORE_SharedPointersMatrix<T> > New() {
        boost::shared_ptr<CORE_SharedPointersMatrix<T> > p(new CORE_SharedPointersMatrix<T>,
                                                           CORE_Object::Delete());
        p->setThis(p);
        return p;
    };

    // OPERATORS
  
    inline const CORE_SharedPointersList<T>& operator[](const tUIndex& i)  const { 
        ASSERT_IN(i<mVector.size());
        return mVector[(int)i];
    };  
    inline CORE_SharedPointersList<T>& operator[](const tUIndex& i) { 
        ASSERT_IN(i<mVector.size());
        return mVector[(int)i];
    };
   
    //COPY
    template<class Q>
    void copy(const CORE_SharedPointersMatrix<Q>& cpy);
  
    // SET 
  
    inline void setSize(const tUIndex& n) {
        mVector.resize(n);
    
    };
    inline void setSize(const tUIndex& n,const tUIndex& p) {
        mVector.resize(n);
        for (tUIndex i=0;i<n;i++) mVector[i].setSize(p);
    
    };
    inline void setRowSize(const tUIndex& i,const tUIndex& r) {
        mVector[i].setSize(r);
    };

    tBoolean set(const tUIndex& i,const tUIndex& j,
                 const boost::shared_ptr<T>& obj) {
        return mVector[i].set(j,obj);
    }
  
    inline tBoolean insert(const tUIndex& i,const tUIndex& j,
                           const boost::shared_ptr<T>& obj) {
        return mVector[i].insert(j,obj);
    };
  
  
    void add(const tUIndex& i,
             const boost::shared_ptr<T>& obj)  {
        mVector[i].add(obj);
    };  


 

  
    inline tBoolean removeAtIndex(const tUIndex& i,
                                  const tUIndex& j) { 
        tUIndex n=mVector.size();
        if (j<n) return mVector[i].removeAtIndex(j);
        return false;
    }
  
    inline tBoolean remove(const boost::shared_ptr<T>& obj) {
        tUIndex n=mVector.size();
        tBoolean ret=false;
        for (tUIndex i=0;i<n;i++) if (mVector[i].remove(obj)) ret=true;
        return ret;
    }

    inline tBoolean remove(const T& obj) {
        tUIndex n=mVector.size();
        tBoolean ret=false;
        for (tUIndex i=0;i<n;i++) if (mVector[i].remove(obj)) ret=true;
        return ret;
    }

    tBoolean remove(const T* obj) {
        tBoolean ret=false;
        tUIndex n=mVector.size();
        for (tUIndex i=0;i<n;i++) if (mVector[i].remove(obj)) ret=true;
        return ret;
    }

  
    inline void removeLine(const tUIndex& i) {
        mVector.erase(i);
    }
  
  
 
    inline void clear(){
        setSize(0,0);
        mVector.clear();
    };

    // GET 
 
 
 
    inline const T* get(const tUIndex& i,const tUIndex& j) const {
        ASSERT_IN(i<mVector.size()); 
        ASSERT_IN(j<mVector[i].size());
    
        return mVector[i][j].get();
    }; 

    inline T* get(const tUIndex& i,const tUIndex& j) {
        ASSERT_IN(i<mVector.size()); 
        ASSERT_IN(j<mVector[i].size());
        return mVector[i][j].get();
    };
  
    inline tUIndex rows() const {return mVector.size();}; 
    inline tUIndex getRowSize(const tUIndex& i) const {return mVector[i].size();};
  
    inline tUIndex getSize() const {return mVector.size();};
  
 
    inline tBoolean exists(const boost::shared_ptr<T>& obj) const {
        tUIndex n=mVector.size();
        for (tUIndex i=0;i<n;i++) if (mVector[i].exists(obj)) return true;
        return false;
    }
    tBoolean exists(const T& obj) const {
        tUIndex n=mVector.size();
        for (tUIndex i=0;i<n;i++) if (mVector[i].exists(obj)) return true;
        return false;
    }

    tBoolean exists(const T* obj) const {
        tUIndex n=mVector.size();
        for (tUIndex i=0;i<n;i++) if (mVector[i].exists(obj)) return true;
        return false;
    }
  
   
    // OTHERS

  
};
#include "CORE_SharedPointersMatrix.hpp"



#endif