Instigate Open Source Documentation

---

src/stl/_matrix.hpp

Go to the documentation of this file.

#ifndef INSTIGATE_STL_MATRIX
#define INSTIGATE_STL_MATRIX

// headers from this project
#include "concept.hpp"

// headers from other projects
#include <generic/_assignable.hpp>
#include <generic/_default_constructible.hpp>

// headers from standard libraries
#include <cassert>

// Forward declarations
namespace instigate {
        namespace stl {
                namespace matrix {
                        template<typename T>
                                struct interface;
                        template<typename T>
                                struct requirements;
                }
        }
}

template <typename T>
struct instigate::stl::matrix::interface
        : instigate::generic::assignable::interface<T>
        , instigate::generic::default_constructible::interface<T>
{
        typedef typename T::size_type size_type;

        typedef typename T::value_type::value_type value_type;

        static size_type get_number_of_rows(const T& x)
        {
                return x.size();
        }

        static size_type get_number_of_columns(const T& x)
        {
                assert(0 < x.size());
                return x[0].size();
        }

        static value_type get_element(const T& x,
                                      const size_type& r, 
                                      const size_type& c)
        {
                assert(get_number_of_rows(x) > r);
                assert(get_number_of_columns(x) > c);
                return x[r][c];
        }

        static void set_element(T& x, 
                                const size_type& r, 
                                const size_type& c, 
                                const value_type& v)
        {
                assert(get_number_of_rows(x) > r);
                assert(get_number_of_columns(x) > c);
                x[r][c] = v;
        }

        static void construct(T& x, const size_type& r, const size_type& c)
        {
                x.resize(r);
                for (size_type i = 0; i < r; ++i) {
                        x[i].resize(c);
                }
        }
};

template <typename T>
struct instigate::stl::matrix::requirements
{
private:

        void require_get_element(const T& x,
                                const typename instigate::stl::
                                matrix:: interface<T>::size_type& r,
                                const typename instigate::stl::
                                matrix:: interface<T>::size_type& c)
        {
                typedef instigate::stl::matrix::interface<T> I;
                typedef typename I::value_type V;
                V v = I::get_element(x, r, c);
        }

        void require_set_element(T& x,
                                const typename instigate::stl::
                                matrix:: interface<T>::size_type& r,
                                const typename instigate::stl::
                                matrix:: interface<T>::size_type& c,
                                const typename instigate::stl::
                                matrix:: interface<T>::value_type& v)
        {
                typedef instigate::stl::matrix::interface<T> I;
                I::set_element(x, r, c, v);
        }

        void require_get_number_of_rows(const T& x)
        {
                typedef instigate::stl::matrix::interface<T> I;
                typedef typename I::size_type S;
                S s = I::get_number_of_rows(x);
        }

        void require_get_number_of_columns(const T& x)
        {
                typedef instigate::stl::matrix::interface<T> I;
                typedef typename I::size_type S;
                S s = I::get_number_of_columns(x);
        }

public:
        requirements()
        {
                (void)require_get_element;
                (void)require_set_element;
                (void)require_get_number_of_rows;
                (void)require_get_number_of_columns;

        }
        
private:
        requirements(const requirements&) throw();

        requirements& operator=(const requirements&) throw();


}; // struct instigate::stl::matrix::requirements

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_STL_MATRIX

---

© Instigate CJSC, Open Source