LAP_ConstVector.h

Go to the documentation of this file.

#ifndef LAP_ConstVector_H
#define LAP_ConstVector_H

#include "LAP_Object.h"
#include "LAP_View.h"

template<class T>
class LAP_ConstVector: public virtual LAP_Object {
  
 private:
  
  // capacity of the mValues
  tLVectorIndex mCapacity;
  
  // values of vector
  const T* mValues;
  
  //view of the vector
  LAP_View mView;
  
  // booelan than indicates if the mValues & mCvector must be destroyed at reallocation or deleting
  tBoolean mIsVectorReference;
  
  
  // METHODS
  
  
 protected:
  // CONSTRUCTORS
    
  LAP_ConstVector();
  
  
  
  
  // DESTRUCTORS
  virtual ~LAP_ConstVector() {
    deleteVector();
  };
  
 private:
  void deleteVector() {
    if (!mIsVectorReference) {
      if (mValues!=null) {
        delete[] mValues;
        mValues=null;
        mCapacity=0;
        mView.reset();
      }
    }
  }
  
  // -----------------------
  // shared pointer operator
  // ------------------------
 public:
  void getSharedPointer(boost::shared_ptr<LAP_ConstVector<T> >& p){
    SP::CORE_Object r;
    CORE_Object::getSharedPointer(r);
    p=boost::dynamic_pointer_cast<LAP_ConstVector<T> >(r);      
  };
  void getSharedPointer( boost::shared_ptr<const LAP_ConstVector<T> >& p) const{                
    SPC::CORE_Object r;
    CORE_Object::getSharedPointer(r);           
    p=boost::dynamic_pointer_cast<const LAP_ConstVector<T> >(r);                                
  }; 
 private:
  inline boost::shared_ptr<LAP_ConstVector<T> > getThis() {
    boost::shared_ptr<LAP_ConstVector<T> > p;
    getSharedPointer(p);
    return p;                           
  }; 
  inline  boost::shared_ptr<const LAP_ConstVector<T> > getThis() const {                                        
    boost::shared_ptr<const LAP_ConstVector<T> > p;
    getSharedPointer(p);
    return p;   
  };
  
 public:
  //ACCESSOR Operators
  //==================
  
  // operators get the i-th element : the view is not taken into account
  inline const T& operator[](const tLVectorIndex& i) const {
    ASSERT_IN(i<mCapacity);
    return mValues[i];
    };
  
  // operators get the i-th element taking into account the view
  inline const T& operator()(const tLVectorIndex& i) const {
    return (*this)[mView.getStart()+mView.getIncrement()*i];
  };
  

  //SET
  inline tBoolean setView(const tLVectorIndex& start,const tLVectorIndex& end,const tLVectorIncrement& increment) {
    if (increment==0) return false;
    if (end<start) return false;
    if (end>mCapacity) return false;
    if (end-increment>mCapacity) return false; 
    mView.setView(start,end,increment);
    return true;
  }
  
  /* \brief set the values to values of size n
   * if isReferenced is true the vector is not destroyed with the class
   * otherwise it is destroyed
   */
  inline void setValues(const tLVectorIndex& n,
                        const T*& values,
                        const tBoolean& isReferenced) {
    
    //delete the old values
    deleteVector();
    //make the pointer to the new values
    mValues=values;
    //set the capacity of the vector to n
    mCapacity=n;
    //set the the values pointer is referenced by another object
    mIsVectorReference=isReferenced;
    
    //update the view
    mView.setView(0,n,1);
  };
  
   
  // GET
  
  
  
 public:
  
  virtual const T* getValues()  const {
    return mValues;
  };
  
  
  
 public:
  inline tLVectorIndex getSize() const {
        return mView.getSize();
  }
  inline const tLVectorIncrement& getIncrement() const {
    return mView.getIncrement();
  }
    inline const tLVectorIndex& getStart() const {
        return mView.getStart();
    }
    inline const tLVectorIndex& getEnd() const {
        return mView.getStart();
    }
    virtual const T& get(const tLVectorIndex& i) const {
        return (*this)(i);
    };
  
   
  
  
    
    
};

#include "LAP_ConstVector.hpp"

#endif