C++-Programmierung/ Eine Matrix-Bibliothek – mitrax/ proxy.hpp

Nuvola-inspired-terminal.svg
#ifndef _mitrax_mitrax_proxy_hpp_INCLUDED_
#define _mitrax_mitrax_proxy_hpp_INCLUDED_
/// \file proxy.hpp
///
/// \brief Proxyklassen für Zeilen und Spalten eines Matrixobjekts
///
/// In dieser Datei werden die vier Proxyklassen definiert, welche jeweils ein Zeile oder Spalte
/// einer konstante oder nicht-konstanten Matrix repräsentieren. Weiterhin steht hier die Funktion
/// <code>element_swap()</code> welche alle Elemente zweier Zeilen oder Spalten miteinander
/// vertauscht.

#include "detail/proxy_iterator.hpp"
#include "exception.hpp"

namespace mitrax{

// Forward-Deklarationen
template < typename Matrix > class row_proxy;
template < typename Matrix > class column_proxy;

namespace detail{

/// \brief Private Basisklasse für alle Proxys
///
/// Diese Klasse enthält die Datenmember der Proxyklassen. Alle vier Proxyklassen werden direkt
/// oder indirekt private von dieser Klasse angeleitet. Es ist nicht möglich Objekte von dieser
/// Klasse zu erzeugen. Die Klasse ist eine Helferklasse mit der ein Benutzer keinen direkten
/// Kontakt haben sollte.
///
/// Compilergenrierte Methoden:
///   - Kopierkonstruktor
///   - Kopierzuweisung
///   - Destruktor
template < typename Matrix >
class line_const_proxy{
protected:
    /// \brief Die Klasseninstanz des Klassentemplats matrix zu der der Proxy gehört
    typedef Matrix                      matrix_type;
    /// \brief Typ der Elemente der Matrix
    typedef typename Matrix::value_type value_type;
    /// \brief Typ der Dimensionselemente der Matrix
    typedef typename Matrix::size_type  size_type;

    /// \brief Konstruktor zur Objekterzeugung aus einem Verweis auf ein konstantes
    ///        <code>matrix</code>-Objekt und einer Zeilen-/Spaltennummer
    line_const_proxy(matrix_type const& matrix, size_type const& pos):
        matrix_(&matrix), pos_(pos){}

    /// \brief Lesezugriff auf die verwaltete Zeilen-/Spaltennummer
    size_type const pos()const{ return pos_; }

    /// \brief Lesezugriff auf die referenzierte Matrix
    matrix_type const& matrix_const()const{ return *matrix_; }

private:
    /// \brief Die referenzierte Matrix
    matrix_type const* matrix_;
    /// \brief Die verwaltete Zeile/Spalte aus der Matrix
    size_type          pos_;
};

/// \brief Private Basisklasse für alle Proxys für nicht-konstante Matrizen
///
/// Diese Klasse stellt das Matrixobjekt als nicht-konstante Referenz zu Verfügung. Alle
/// Proxyklassen für nicht-konstante Matrizen werden private von dieser Klasse angeleitet. Es ist
/// nicht möglich Objekte von dieser Klasse zu erzeugen. Die Klasse ist eine Helferklasse mit der
/// ein Benutzer keinen direkten Kontakt haben sollte.
///
/// Compilergenerierte Methoden:
///   - Kopierkonstruktor
///   - Kopierzuweisung
///   - Destruktor
template < typename Matrix >
class line_proxy: protected line_const_proxy< Matrix >{
protected:
    /// \brief Die Klasseninstanz des Klassentemplats matrix zu der der Proxy gehört
    typedef Matrix                      matrix_type;
    /// \brief Typ der Elemente der Matrix
    typedef typename Matrix::value_type value_type;
    /// \brief Typ der Dimensionselemente der Matrix
    typedef typename Matrix::size_type  size_type;

    /// \brief Konstruktor zur Objekterzeugung aus einem Verweis auf <code>matrix</code>-Objekt und
    ///        einer Zeilen-/Spaltennummer
    line_proxy(matrix_type& matrix, size_type const& pos):
        detail::line_const_proxy< matrix_type >(matrix, pos){}

    /// \brief Schreibzugriff auf die referenzierte Matrix
    matrix_type& matrix()const{ return const_cast< matrix_type& >(this->matrix_const()); }
};

/// \brief Helfer zu Iteratorerzeugung in Zeilenproxys (<code>begin()</code>)
template < typename Matrix, typename Iterator >
inline
Iterator const
create_begin_row_iterator(
    Matrix& matrix,
    typename Matrix::size_type const& row
){
    return Iterator(
        matrix.begin() + (matrix.columns() * row)
    );
}

/// \brief Helfer zu Iteratorerzeugung in Zeilenproxys (<code>end()</code>)
template < typename Matrix, typename Iterator >
inline
Iterator const
create_end_row_iterator(
    Matrix& matrix,
    typename Matrix::size_type const& row
){
    return Iterator(
        matrix.begin() + (matrix.columns() * (row + 1))
    );
}


/// \brief Helfer zu Iteratorerzeugung in Spaltenproxys (<code>begin()</code>)
template < typename Matrix, typename Iterator >
inline
Iterator const
create_begin_column_iterator(
    Matrix& matrix,
    typename Matrix::size_type const& column
){
    return Iterator(
        matrix,
        column
    );
}

/// \brief Helfer zu Iteratorerzeugung in Spaltenproxys (<code>end()</code>)
template < typename Matrix, typename Iterator >
inline
Iterator const
create_end_column_iterator(
    Matrix& matrix,
    typename Matrix::size_type const& column
){
    return Iterator(
        matrix,
        column + matrix.columns() * matrix.rows()
    );
}

}

/// \brief Proxyklasse die eine Zeile eines konstanten <code>matrix</code>-Objekts repräsentiert
template < typename Matrix >
class row_const_proxy: private detail::line_const_proxy< Matrix >{
public:
    /// \brief Die Klasseninstanz des Klassentemplats <code>matrix</code> zu der der Proxy gehört
    typedef Matrix                                    matrix_type;
    /// \brief Typ der Elemente der Matrix
    typedef typename Matrix::value_type               value_type;
    /// \brief Iteratoren für Lesezugriff
    typedef detail::row_const_iterator< matrix_type > const_iterator;
    /// \brief Iteratoren für Lesezugriff
    typedef const_iterator                            iterator;
    /// \brief Typ der Dimensionselemente der Matrix
    typedef typename Matrix::size_type                size_type;
    /// \brief <code>difference_type</code> der Iteratoren
    typedef typename const_iterator::difference_type  difference_type;

    /// \brief Objekterzeugung aus einem Verweis auf ein konstantes <code>matrix</code>-Objekt und
    ///        einer Zeilennummer
    row_const_proxy(matrix_type const& matrix, size_type const& row):
        detail::line_const_proxy< matrix_type >(matrix, row){}

    /// \brief Lesezugriff auf das Element <code>column_number</code>
    ///
    /// siehe <code>column()</code>
    value_type const&
    operator[](size_type const& column_number)const{ return column(column_number); }
    /// \brief Lesezugriff auf das Element number
    value_type const& column(size_type const& number)const{ return *(begin() + number); }

    /// \brief Anzahl der Spalten
    size_type const columns()const{ return this->matrix_const().columns(); }
    /// \brief Anzahl der Spalten
    ///
    /// siehe <code>columns()</code>
    size_type const size()const{ return columns(); }

    /// \brief Zeile die das Objekt repräsentiert
    size_type const pos()const{ return detail::line_const_proxy< matrix_type >::pos(); }

    /// \brief Leseiterator auf das erste Element
    const_iterator const begin()const{ return cbegin(); }

    /// \brief Leseiterator hinter das letzte Element
    const_iterator const end()const{ return cend(); }

    /// \brief Leseiterator auf das erste Element
    const_iterator const cbegin()const{
        return detail::create_begin_row_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }

    /// \brief Leseiterator hinter das letzte Element
    const_iterator const cend()const{
        return detail::create_end_row_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }
};

/// \brief Proxyklasse die eine Spalte eines konstanten <code>matrix</code>-Objekts repräsentiert
template < typename Matrix >
class column_const_proxy: private detail::line_const_proxy< Matrix >{
public:
    /// \brief Die Klasseninstanz des Klassentemplats <code>matrix</code> zu der der Proxy gehört
    typedef Matrix                                       matrix_type;
    /// \brief Typ der Elemente der Matrix
    typedef typename Matrix::value_type                  value_type;
    /// \brief Iteratoren für Lesezugriff
    typedef detail::column_const_iterator< matrix_type > const_iterator;
    /// \brief Iteratoren für Lesezugriff
    typedef const_iterator                               iterator;
    /// \brief Typ der Dimensionselemente der Matrix
    typedef typename Matrix::size_type                   size_type;
    /// \brief <code>difference_type</code> der Iteratoren
    typedef typename const_iterator::difference_type     difference_type;

    /// \brief Objekterzeugung aus einem Verweis auf ein konstantes <code>matrix</code>-Objekt und
    ///        einer Spaltennummer
    column_const_proxy(matrix_type const& matrix, size_type const& column):
        detail::line_const_proxy< matrix_type >(matrix, column){}

    /// \brief Lesezugriff auf das Element <code>row_number</code>
    ///
    /// siehe <code>row()</code>
    value_type const& operator[](size_type const& row_number)const{ return row(row_number); }
    /// \brief Lesezugriff auf das Element number
    value_type const& row(size_type const& number)const{ return *(begin() + number); }

    /// \brief Anzahl der Zeilen
    size_type const rows()const{ return this->matrix_const().rows(); }
    /// \brief Anzahl der Zeilen
    ///
    /// siehe <code>rows()</code>
    size_type const size()const{ return rows(); }

    /// \brief Spalte die das Objekt repräsentiert
    size_type const pos()const{ return detail::line_const_proxy< matrix_type >::pos(); }

    /// \brief Leseiterator auf das erste Element
    const_iterator const begin()const{ return cbegin(); }

    /// \brief Leseiterator hinter das letzte Element
    const_iterator const end()const{ return cend(); }

    /// \brief Leseiterator auf das erste Element
    const_iterator const cbegin()const{
        return detail::create_begin_column_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }

    /// \brief Leseiterator hinter das letzte Element
    const_iterator const cend()const{
        return detail::create_end_column_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }
};


/// \brief Proxyklasse die eine Zeile eines <code>matrix</code>-Objekts repräsentiert
template < typename Matrix >
class row_proxy: private detail::line_proxy< Matrix >{
public:
    /// \brief Die Klasseninstanz des Klassentemplats <code>matrix</code> zu der der Proxy gehört
    typedef Matrix                                                   matrix_type;
    /// \brief Typ der Elemente der Matrix
    typedef typename Matrix::value_type                              value_type;
    /// \brief Iteratoren für Lesezugriff
    typedef typename row_const_proxy< matrix_type >::const_iterator  const_iterator;
    /// \brief Iteratoren für Schreibzugriff
    typedef detail::row_iterator< matrix_type >                      iterator;
    /// \brief Typ der Dimensionselemente der Matrix
    typedef typename Matrix::size_type                               size_type;
    /// \brief <code>difference_type</code> der Iteratoren
    typedef typename row_const_proxy< matrix_type >::difference_type difference_type;

    /// \brief Objekterzeugung aus einem Verweis auf ein <code>matrix</code>-Objekt und einer
    ///        Zeilennummer
    row_proxy(matrix_type& matrix, size_type const& row):
        detail::line_proxy< matrix_type >(matrix, row){}

    /// \brief Schreibzugriff auf das Element <code>column_number</code>
    ///
    /// siehe <code>column()</code>
    value_type& operator[](size_type const& column_number)const{ return column(column_number); }
    /// \brief Schreibzugriff auf das Element <code>number</code>
    value_type& column(size_type const& number)const{ return *(begin() + number); }

    /// \brief Anzahl der Spalten
    size_type const columns()const{ return this->matrix_const().columns(); }
    /// \brief Anzahl der Spalten
    ///
    /// siehe <code>columns()</code>
    size_type const size()const{ return columns(); }

    /// \brief Zeile die das Objekt repräsentiert
    size_type const pos()const{ return detail::line_proxy< matrix_type >::pos(); }


    /// \brief Schreibiterator auf das erste Element
    iterator const begin()const{
        return detail::create_begin_row_iterator< matrix_type, iterator >(this->matrix(), pos());
    }

    /// \brief Schreibiterator hinter das letzte Element
    iterator const end()const{
        return detail::create_end_row_iterator< matrix_type, iterator >(this->matrix(), pos());
    }

    /// \brief Leseiterator auf das erste Element
    const_iterator const cbegin()const{
        return detail::create_begin_row_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }

    /// \brief Leseiterator hinter das letzte Element
    const_iterator const cend()const{
        return detail::create_end_row_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }

    /// \brief Typumwandlung in <code>row_const_proxy< matrix_type ></code>
    operator row_const_proxy< matrix_type >()const{
        return row_const_proxy< matrix_type >(this->matrix_const(), this->pos());
    }
};

/// \brief Proxyklasse die eine Spalte eines konstanten <code>matrix</code>-Objekts repräsentiert
template < typename Matrix >
class column_proxy: private detail::line_proxy< Matrix >{
public:
    /// \brief Die Klasseninstanz des Klassentemplats <code>matrix</code> zu der der Proxy gehört
    typedef Matrix                                                      matrix_type;
    /// \brief Typ der Elemente der Matrix
    typedef typename Matrix::value_type                                 value_type;
    /// \brief Iteratoren für Lesezugriff
    typedef typename column_const_proxy< matrix_type >::const_iterator  const_iterator;
    /// \brief Iteratoren für Schreibzugriff
    typedef detail::column_iterator< matrix_type >                      iterator;
    /// \brief Typ der Dimensionselemente der Matrix
    typedef typename Matrix::size_type                                  size_type;
    /// \brief <code>difference_type</code> der Iteratoren
    typedef typename column_const_proxy< matrix_type >::difference_type difference_type;

    /// \brief Objekterzeugung aus einem Verweis auf ein <code>matrix</code>-Objekt und einer
    ///        Spaltennummer
    column_proxy(matrix_type& matrix, size_type const& column):
        detail::line_proxy< matrix_type >(matrix, column){}

    /// \brief Schreibzugriff auf das Element <code>row_number</code>
    ///
    /// siehe <code>row()</code>
    value_type& operator[](size_type const& row_number)const{ return row(row_number); }
    /// \brief Schreibzugriff auf das Element number
    value_type& row(size_type const& number)const{ return *(begin() + number); }

    /// \brief Anzahl der Zeilen
    size_type const rows()const{ return this->matrix_const().rows(); }
    /// \brief Anzahl der Zeilen
    ///
    /// siehe <code>rows()</code>
    size_type const size()const{ return rows(); }

    /// \brief Spalte die das Objekt repräsentiert
    size_type const pos()const{ return detail::line_proxy< matrix_type >::pos(); }

    /// \brief Schreibiterator auf das erste Element
    iterator const begin()const{
        return detail::create_begin_column_iterator< matrix_type, iterator >(
            this->matrix(), pos()
        );
    }

    /// \brief Schreibiterator hinter das letzte Element
    iterator const end()const{
        return detail::create_end_column_iterator< matrix_type, iterator >(this->matrix(), pos());
    }

    /// \brief Leseiterator auf das erste Element
    const_iterator const cbegin()const{
        return detail::create_begin_column_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }

    /// \brief Leseiterator hinter das letzte Element
    const_iterator const cend()const{
        return detail::create_end_column_iterator< matrix_type const, const_iterator >(
            this->matrix_const(), pos()
        );
    }

    /// \brief Typumwandlung in <code>column_const_proxy< matrix_type ></code>
    operator column_const_proxy< matrix_type >()const{
        return column_const_proxy< matrix_type >(this->matrix_const(), this->pos());
    }
};



namespace detail{

/// \brief Helferfunktion für <code>element_swap()</code>
template < typename Proxy >
inline
void
element_swap_template(
    Proxy const& lhs,
    Proxy const& rhs
){
    typedef typename Proxy::iterator iterator;
    using std::swap;

    // kompatibilität prüfen
    if(lhs.size() != rhs.size()){
        throw error::size_unequal("mitrax::element_swap_template<>()", lhs.size(), rhs.size());
    }

    // Elementweise tauschen
    for(
        iterator i = lhs.begin(), j = rhs.begin();
        i != lhs.end();
        ++i, ++j
    ){
        swap(*i, *j);
    }
}

}

/// \brief Vertauscht Elemente zweier Zeilen
template < typename Matrix >
inline
void
element_swap(row_proxy< Matrix > const& lhs, row_proxy< Matrix > const& rhs){
    detail::element_swap_template(lhs, rhs);
}

/// \brief Vertauscht Elemente zweier Spalten
template < typename Matrix >
inline
void
element_swap(column_proxy< Matrix > const& lhs, column_proxy< Matrix > const& rhs){
    detail::element_swap_template(lhs, rhs);
}


}

#endif