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

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


 

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

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

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

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

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

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

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

  
};
#include "CORE_SharedPointersMatrix.hpp"



#endif