Matrix.hpp

#ifndef OPALS_MATRIX_HPP_INCLUDED
#define OPALS_MATRIX_HPP_INCLUDED

#include <opals/fwd.hpp>

#include <cstddef>

namespace opals {

  /**
  \class  Matrix
  \tparam T element type
  \tparam M number of rows
  \tparam N number of columns

  \brief A template class for storing a two-dimensional array of constant size.

  Symbols for Matrix are exported to opals DLLs as required by their modules' interfaces,
    meaning that DLL users are able to instantiate Matrix<T,M,N> only with the corresponding template arguments.
    The interface is based on boost::numeric::ublas::c_matrix

  \author wk
  \date   06.02.2011

  \internal
  opals::Matrix features a constant size, because otherwise, parsing would become more difficult
  ( we would need to define a syntax for row/column breaks).
  Note, however, that the template parameters M and N merely define an upper limit to the extents of the underlying ublas::c_matrix,
  which may be smaller when the according ublas-functions have been applied.
  Conversion constructors and operators for boost::numeric::ublas::c_matrix<T,M,N> are provided for internal use only.
  If T is another interface class (e.g. opals::String),
  then use function toInternal() to convert to boost::numeric::ublas::c_matrix<std::string,M,N>.
  opals::Matrix encapsulates boost::ublas::c_matrix, whose implementation it hides from the
  interface in order to provide self-contained code.
  As ublas provides highly optimized template expressions, users are expected
  to use opals::Matrix only when communicating with the interface, why no further operators are exposed.
  */

  template< class T, std::size_t M, std::size_t N >
  class Matrix
  {
    class Impl;
    Impl *pimpl_;

  public:

    typedef T                     value_type;
    typedef T*                    pointer;
    typedef T&                    reference;
    typedef T const&              const_reference;
    typedef std::size_t           size_type;

    static const size_type _nRows = M;
    static const size_type _nCols = N;

    /// \name construction / destruction
    /// n.b.: use clear() to initialize the Matrix
    ///@{
    Matrix();

    Matrix( const Matrix& other );

    ~Matrix();
    ///}@

    /// \name initialization
    ///@{
    /// all elements are set to T()
    void clear();
    ///}@

    /// \name assignment, swapping
    ///@{
    Matrix& operator=( const Matrix& other );
    void swap( Matrix& other );
    ///}@

    /// \name direct data access
    /// zero-based indexing
    ///@{
    reference       operator()( size_type r, size_type c );
    const_reference operator()( size_type r, size_type c ) const;
    ///}@

    /// \name size
    ///@{
    size_type nRows()     const;
    size_type nCols()     const;
    ///}@

  };

}

#endif