//Purpose:
//  Compare storage order's in multi_array and array_dyn.
//Results:
//  multi_array fortran_storage == array_dyn dir_fwd
//  multi_array       c_storage == array_dyn dir_rev
#include <boost/multi_array.hpp>
#include <boost/utility/enable_if.hpp>
#include <numeric>
#include <iostream>
#include <boost/iostreams/utility/indent_scoped_ostreambuf.hpp>
#include <boost/array_stepper/array_dyn.hpp>

using namespace boost;

typedef unsigned element_t;

  template
  < typename MultiArray
  >
struct is_multi_array
: mpl::false_
{
};
  template
  < typename T
  , std::size_t NumDims
  >
struct is_multi_array
  < multi_array<T,NumDims>
  >
: mpl::true_
{};
  template
  < typename T
  , std::size_t NumDims
  , typename TPtr
  >
struct is_multi_array
  < detail::multi_array::const_sub_array<T,NumDims,TPtr>
  >
: mpl::true_
{};
  
  template
  < typename MultiArray
  >
  typename enable_if<is_multi_array<MultiArray>, std::ostream&>::type
operator<<
  ( std::ostream& sout
  , MultiArray const& arr
  )
  {
    //unsigned num_dims=arr.num_dimensions();
      typename MultiArray::const_iterator 
    beg(arr.begin()), now(beg), end(arr.end());
    sout<<"{ ";
    for(unsigned i=0; now!=end; ++now,++i)
    {
        if(0<i) sout<<", ";
        sout<<indent_buf_in;
        sout<<*now;
        sout<<indent_buf_out;
    }
    sout<<"}\n";
    return sout;
  }
  
  template
  < typename Array
  >
  void
iota_init
  ( Array& arr
  , element_t value0=0
  )
  {
      std::iota( arr.data(), arr.data()+arr.num_elements(), value0);
  }
  
  template
  < typename T
  >
  void
iota_init
  ( array_stepper::array_dyn<T>& arr
  , element_t value0=0
  )
  {
      std::iota( arr.my_data.begin(), arr.my_data.end(), value0);
  }
  
  template
  < std::size_t NumDims
  >
  std::ostream&
operator<<
  ( std::ostream& sout
  , general_storage_order<NumDims>const& so
  )
  {
      sout<<"{ ";
      for(unsigned i=0; i<NumDims; ++i)
      {
          if(0<i) sout<<", ";
          sout<<"( ordering="<<so.ordering(i)<<", ascending="<<so.ascending(i)<<")";
      }
      return sout<<"}\n";
  }

int main(void)
{
    boost::iostreams::indent_scoped_ostreambuf<char> indent_outbuf(std::cout,2);
    std::size_t const num_dims=3;
    {
        std::cout<<"multi_array:\n";
        std::cout<<indent_buf_in;
        typedef multi_array<element_t,num_dims> array_type;
        enum {fortran_so, c_so};
        general_storage_order<num_dims> so[c_so+1]
          ={ fortran_storage_order()
           , c_storage_order()
           };
        char const*name_so[c_so+1]={"fortran","c"};
        for(unsigned iso=fortran_so; iso<=c_so; iso++)
        {
            std::cout<<name_so[iso]<<"_order="<<so[iso]<<"\n";
            array_type ma( extents[2][3][4], so[iso]);
            iota_init(ma,1000);
            std::cout<<ma<<"\n";
        }
        std::cout<<indent_buf_out;
    }
    {
        using namespace array_stepper;
        std::cout<<"array_dyn:\n";
        std::cout<<indent_buf_in;
        typedef array_stepper::array_dyn<element_t> array_type;
        array_type::lengths_t a_lengths({2,3,4});
        dirs so[dir_rev+1]={dir_fwd,dir_rev};
        char const*name_so[dir_rev+1]={"fwd","rev"};
        for(unsigned iso=dir_fwd; iso<=dir_rev; iso++)
        {
            std::cout<<"dir="<<name_so[iso]<<"\n";
            array_type ma( so[iso], a_lengths);
            iota_init(ma,1000);
            std::cout<<ma<<"\n";
        }
        std::cout<<indent_buf_out;
    }
    return 0;
}