ivl/details/array/impl/catarray.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/>. */

#ifndef IVL_DETAILS_ARRAY_CATARRAY_HPP
#define IVL_DETAILS_ARRAY_CATARRAY_HPP

namespace ivl {

namespace array_details {

template <class A1, class A2, int CATDIM>
struct catarray_result
{
        //need both be non-const
        /*
        typedef typename types::t_if<types::is_const<A>,
                const typename A::derived_type, typename A::derived_type>::type a;

        typedef typename types::change_data_class_set<
                data::catarray<a, I>, typename A::derived_type>::type type;
                */
};

} /* namespace array_details */
/*
template <class A1, class A2, int CD>
class catarray : public array_details::catarray_result<A1, A2, CD>::type
{
public:
        //operator catarray&() const { } //TODO: lets see..
        //catarray& operator*() { return const_cast<catarray&>(*this); }
        catarray& ref() { return *this; }

        typedef typename array_details::catarray_result<A1, A2, CD>
                ::type base_class;

        typedef typename base_class::elem_type elem_type;

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

        catarray(A1& a1, A2& a2, int dim = CD) { this->setref(a.derived(), i); }

        catarray(const catarray& a) : base_class(a.derived()) { }

        using base_class::operator();

        //using base_class::operator=;
        template<class K>
        catarray& operator=(const K& k)
        { base_class::operator=(k); return *this; }

        catarray& operator=(const catarray& o)
        { base_class::operator=(o); return *this; }



};
*/



template <class A1, class A2, int CD>
class concat : public array_nd<typename A1::elem_type,
        data::catarray<A1, A2, CD> >
{
public:
        concat& ref() { return *this; }

        typedef array_nd<typename A1::elem_type,
        data::catarray<A1, A2, CD> > base_class;

        typedef typename base_class::elem_type elem_type;

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

        concat(A1& a1, A2& a2, int dim = CD) :
        base_class(a1.size() + a2.size(dim) * cast<int>(rng(0, a2.ndims()-1) == dim))
                { this->setref(a1, a2, dim); }

/*
        template<class TP>
        concat(const internal::tuple_base<2, TP>& tp) :
        base_class(tp.derived().v1.size() + tp.derived().v2.size(CD) *
                                cast<int>(rng(0, tp.derived().v2.ndims()-1) == CD))
                { this->setref(tp.derived().v1, tp.derived().v2, CD); }
*/
        template<class T1, class T2>
        concat(const internal::tuple<T1, T2>& tp) :
        base_class(tp.v1.size() + tp.v2->size(CD) *
                                cast<int>(rng(0, tp.v2->ndims()-1) == CD))
                { this->setref(tp.v1, *tp.v2, CD); }


        concat(const concat& a) : base_class(a.derived()) { }

        using base_class::operator();

        //using base_class::operator=;
        template<class K>
        concat& operator=(const K& k)
        { base_class::operator=(k); return *this; }

        concat& operator=(const concat& o)
        { base_class::operator=(o); return *this; }



};

} /* namespace ivl */

#endif // IVL_DETAILS_ARRAY_CATARRAY_HPP