#define BOOST_TEST_MODULE $Id: test_fill.cc 890 2010-01-06 03:56:22Z rhys $
#include <algorithm>
#include <boost/mpl/list.hpp>
#include <boost/multi_array.hpp>
#include <boost/test/included/unit_test.hpp>
#include <boost/test/test_case_template.hpp>

template<std::size_t D>
struct fill_functor {
    template< class Array, class V >
    void operator()(Array x, const V &v) {

        fill_functor<D-1> f;
        for (typename Array::iterator i = x.begin(); i != x.end(); ++i) {
            typename Array::iterator::reference ri = *i;
            f(ri,v);
        }
    }
};

template<> struct fill_functor<1> {
    template< class Array, class V >
    void operator()(Array x, const V &v) {
        std::fill(x.begin(), x.end(), v);
    }
};

template<> struct fill_functor<0> { /* error on zero dimensional */ };

template<class Array, class V>
void fill(Array &x, const V &v) {
    fill_functor<Array::dimensionality>()(x,v);
}

template<class V1, std::size_t NumDims, class Allocator, class V2>
void fill(boost::multi_array<V1,NumDims,Allocator> &x, const V2 &v) {
        std::fill_n(x.data(), x.num_elements(), v);
}

template<class V1, std::size_t NumDims, class V2>
void fill(boost::multi_array_ref<V1,NumDims> &x, const V2 &v) {
        std::fill_n(x.data(), x.num_elements(), v);
}

typedef boost::mpl::list<float, double, long double> test_types;

BOOST_AUTO_TEST_CASE_TEMPLATE(fill_multiarray_1D, T, test_types)
{
    typedef boost::multi_array_types::index_range range;

    boost::multi_array<T,1> foo(boost::extents[3]);
    fill(foo,123);
    for (boost::multi_array_types::index i = 0; i < foo.shape()[0]; ++i) {
        BOOST_CHECK_EQUAL(123, foo[i]);
    }

    typename boost::array_view_gen<boost::multi_array<T,1>,1>::type bar
        = foo[ boost::indices[range()] ];
    fill(bar,456);
    for (boost::multi_array_types::index i = 0; i < bar.shape()[0]; ++i) {
        BOOST_CHECK_EQUAL(456, bar[i]);
    }

    boost::scoped_array<T> raw(new T[3]);
    boost::multi_array_ref<T,1> baz(raw.get(),boost::extents[3]);
    fill(baz,123);
    for (boost::multi_array_types::index i = 0; i < baz.shape()[0]; ++i) {
        BOOST_CHECK_EQUAL(123, baz[i]);
    }

    typename boost::array_view_gen<boost::multi_array_ref<T,1>,1>::type qux
        = bar[ boost::indices[range()] ];
    fill(qux,456);
    for (boost::multi_array_types::index i = 0; i < qux.shape()[0]; ++i) {
        BOOST_CHECK_EQUAL(456, qux[i]);
    }
}

BOOST_AUTO_TEST_CASE_TEMPLATE(fill_multiarray_2D, T, test_types)
{
    typedef boost::multi_array_types::index_range range;

    boost::multi_array<T,2> foo(boost::extents[3][4]);
    fill(foo,123);
    for (boost::multi_array_types::index i = 0; i < foo.shape()[0]; ++i) {
        for (boost::multi_array_types::index j = 0; j < foo.shape()[1]; ++j) {
            BOOST_CHECK_EQUAL(123, foo[i][j]);
        }
    }

    typename boost::array_view_gen<boost::multi_array<T,2>,2>::type bar
        = foo[ boost::indices[range()][range()] ];
    fill(bar,456);
    for (boost::multi_array_types::index i = 0; i < bar.shape()[0]; ++i) {
        for (boost::multi_array_types::index j = 0; j < bar.shape()[1]; ++j) {
            BOOST_CHECK_EQUAL(456, bar[i][j]);
        }
    }

    boost::scoped_array<T> raw(new T[3*4]);
    boost::multi_array_ref<T,2> baz(raw.get(),boost::extents[3][4]);
    fill(baz,123);
    for (boost::multi_array_types::index i = 0; i < baz.shape()[0]; ++i) {
        for (boost::multi_array_types::index j = 0; j < baz.shape()[1]; ++j) {
            BOOST_CHECK_EQUAL(123, baz[i][j]);
        }
    }

    typename boost::array_view_gen<boost::multi_array_ref<T,2>,2>::type qux
        = bar[ boost::indices[range()][range()] ];
    fill(qux,456);
    for (boost::multi_array_types::index i = 0; i < qux.shape()[0]; ++i) {
        for (boost::multi_array_types::index j = 0; j < qux.shape()[0]; ++j) {
            BOOST_CHECK_EQUAL(456, qux[i][j]);
        }
    }
}