AbstractLinAlgPack_VectorDenseEncap.hpp

// /////////////////////////////////////////////////////////////////////
// AbstractLinAlgPack_VectorDenseEncap.hpp

#ifndef SLAP_VECTOR_DENSE_ENCAP_H
#define SLAP_VECTOR_DENSE_ENCAP_H

#include "AbstractLinAlgPack_Types.hpp"
#include "AbstractLinAlgPack_VectorMutable.hpp"
#include "DenseLinAlgPack_DVectorClass.hpp"

namespace AbstractLinAlgPack {

class VectorDenseEncap {
public:

  VectorDenseEncap( const Vector&  vec );
  ~VectorDenseEncap();
  const DVectorSlice& operator()() const;

private:

  const Vector            &vec_;
  RTOpPack::SubVector     sub_vec_;
  DVectorSlice            vs_;
  VectorDenseEncap();                                     // Not defined and not to be called!
  VectorDenseEncap(const VectorDenseEncap&);              // ""
  VectorDenseEncap& operator=(const VectorDenseEncap&);   // ""

}; // end class VectorDenseEncap

class VectorDenseMutableEncap {
public:

  VectorDenseMutableEncap( VectorMutable&  vec );
  ~VectorDenseMutableEncap();
  DVectorSlice& operator()();
  const DVectorSlice& operator()() const;

private:

  VectorMutable                  &vec_;
  RTOpPack::MutableSubVector     sub_vec_;
  DVectorSlice                   vs_;
  VectorDenseMutableEncap();                                            // Not defined and not to be called!
  VectorDenseMutableEncap(const VectorDenseMutableEncap&);              // ""
  VectorDenseMutableEncap& operator=(const VectorDenseMutableEncap&);   // ""

}; // end class VectorDenseMutableEncap

// ///////////////////////////////////////////
// Inline members

// VectorDenseEncap

inline
VectorDenseEncap::VectorDenseEncap( const Vector&  vec )
  :vec_(vec)
{
  vec_.get_sub_vector(Range1D(),&sub_vec_);
  vs_.bind( DVectorSlice(
          const_cast<value_type*>(sub_vec_.values())
          ,sub_vec_.subDim()
          ,sub_vec_.stride()
          )
    );
}

inline
VectorDenseEncap::~VectorDenseEncap()
{
  vec_.free_sub_vector(&sub_vec_);
}

inline
const DVectorSlice& VectorDenseEncap::operator()() const
{
  return vs_;
}

// VectorDenseMutableEncap

inline
VectorDenseMutableEncap::VectorDenseMutableEncap( VectorMutable&  vec )
  :vec_(vec)
{
  vec_.get_sub_vector(Range1D(),&sub_vec_);
  vs_.bind( DVectorSlice(
          sub_vec_.values()
          ,sub_vec_.subDim()
          ,sub_vec_.stride()
          )
    );
}

inline
VectorDenseMutableEncap::~VectorDenseMutableEncap()
{
  vec_.commit_sub_vector(&sub_vec_);
}

inline
DVectorSlice& VectorDenseMutableEncap::operator()()
{
  return vs_;
}

inline
const DVectorSlice& VectorDenseMutableEncap::operator()() const
{
  return vs_;
}

} // end namespace SparseLinALgPack

#endif // SLAP_VECTOR_DENSE_ENCAP_H