ivl/details/array_2d/impl/specialization/array_2d_class.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
   See the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */



template <class T,
                 class OPTS = data::normal_2d<>
             >
class array_2d :
        public
        array_common_base<array_2d<T, OPTS> >
{
private:
        typedef array_common_base<array_2d<T, OPTS> > common_base_class;

public:
        typedef array_2d this_type;

        typedef this_type this_array_2d_type;

        typedef typename this_type::derived_type derived_type;

        typedef typename common_base_class::base_class base_class;

        typedef this_type array_type;

        typedef typename this_type::size_type size_type;

        using base_class::derived;

        typedef typename this_type::is_resizeable is_resizeable;

        typedef typename this_type::all_init_arg_base all_init_arg;
        typedef typename this_type::data_init_arg_base data_init_arg;

        base_class& base() { return *this; }
        const base_class& base() const { return *this; }

        size_t rows() const { return this->size_nd()[0]; }

        size_t columns() const { return this->size_nd()[1]; }
        size_t cols() const { return this->size_nd()[1]; }

        bool is_square() const { return rows() == columns(); }


        template <class S>
        void resize(const array<size_t, S>& newsize, const T& s,
                types::enable_if<is_resizeable> = 0)
        {
                CHECK(newsize.length() == 2, eshape());
                base_class::resize(newsize, s);
        }

        template <class S>
        void resize(const array<size_t, S>& newsize)
        {
                CHECK(newsize.length() == 2, eshape());
                base_class::resize(newsize);
        }

        void resize(size_t rows, size_t cols, const T& s,
                types::enable_if<is_resizeable> = 0)
        {
                base_class::resize(size_dims<2>(rows, cols), s);
        }

        void resize(size_t rows, size_t cols,
                types::enable_if<is_resizeable> = 0)
        {
                data::call_if<is_resizeable>::
			resize(base(), size_dims<2>(rows, cols));
        }
        array_2d() { }

        array_2d(size_t r, size_t c) :
                common_base_class(size_dims<2>(r, c)) {} ;

        template <class D>
        array_2d(const array<size_t, D>& sz) :
                common_base_class(sz) {} ;


        array_2d(size_t r, size_t c, const T& s) :
                common_base_class(size_dims<2>(r, c), s) {} ;

        array_2d(size_t r, size_t c, const T* data) :
                common_base_class(size_dims<2>(r, c), data) {} ;


        array_2d(size_t r, size_t c, const data_init_arg& data) :
                common_base_class(size_dims<2>(r, c), data) {} ;


        template <class J, class D>
        array_2d(size_t r, size_t c, const array<J, D>& data) :
                common_base_class(size_dims<2>(r, c), data)
                { }



        template <class D>
        array_2d(const array<size_t, D>& sz, const T& s) :
                common_base_class(sz, s) {} ;


        template <class D>
        array_2d(const array<size_t, D>& sz, const T* data) :
                common_base_class(sz, data) {} ;

        template <class D>
        array_2d(const array<size_t, D>& sz, const data_init_arg& data) :
                common_base_class(sz, data) {} ;


        template <class D, class J, class S>
        array_2d(const array<size_t, D>& sz, const array<J, S>& data) :
                common_base_class(sz, data)
        {
                CHECK(sz.length() == 2, edims);
                CHECK(data.length() >= sz[0] * sz[1], erange);
        }

        template <class J, class D>
        array_2d(const array_nd<J, D>& a) :
                common_base_class(a)
                { 
                        // code to assert 2 dimensions
                        if(a.ndims() != 2) this->reshape(array_details::dims_for_2d(a.size()));
                }

        template <class J, class D>
        array_2d(array_nd<J, D>& a) :
                common_base_class(a)
                {
                        // code to assert 2 dimensions
                        if(a.ndims() != 2) this->reshape(array_details::dims_for_2d(a.size()));
                }

        
        // ----------------------

        template <class J, class D>
        array_2d(const array_2d<J, D>& a) :
                common_base_class(a)
                { }

        //(special for ref_iterator)
        template <class J, class D>
        array_2d(array_2d<J, D>& a) :
                common_base_class(a)
                { }

        // ----------------------

        array_2d(const this_type& a) :
                common_base_class(a) {} ;



#ifdef IVL_MATLAB

        array_2d(const mxArray* mx);
#endif



        //using base_class::operator=;

        using common_base_class::operator ();

        template <class K>
        derived_type& operator=(const K& a)
        { common_base_class::operator=(a); return derived(); }

        this_type& operator=(const this_type& a)
        { common_base_class::operator=(a); return *this; }

        //array_2d <T, DerivedInfo>& operator=(const array_2d<T, DerivedInfo>& a)
        //      { base_class::operator=(a); return *this; /*TODO: assure check for self assignment (in all classes!)*/ };

//
//      template<class S>
//      Derived& operator=(const array_2d<T, S>& a)
//              { return base_class::operator=(a); /*TODO: assure check for self assignment*/ };

#ifdef IVL_MATLAB

        array_2d<T>& operator=(const mxArray* mx);
#endif

/*
        std::ostream& print_me(std::ostream& os) const
                { return ivl::print(os, *this); }
*/

#ifdef IVL_MATLAB

        mxArray* mx();
#endif

};