// Copyright 2002 The Trustees of Indiana University.

 // Use, modification and distribution is subject to the Boost Software 

 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 //  Boost.MultiArray Library

 //  Authors: Ronald Garcia

 //           Jeremy Siek

 //           Andrew Lumsdaine

 //  See http://www.boost.org/libs/multi_array for documentation.

 #ifndef BOOST_STORAGE_ORDER_RG071801_HPP

 #define BOOST_STORAGE_ORDER_RG071801_HPP

 #include "boost/multi_array/types.hpp"

 #include "boost/array.hpp"

 #include "boost/multi_array/algorithm.hpp"

 #include <algorithm>

 #include <cstddef>

 #include <functional>

 #include <numeric>

 #include <vector>

 namespace boost {

   // RG - This is to make things work with VC++. So sad, so sad.

   class c_storage_order; 

   class fortran_storage_order;

   template <std::size_t NumDims>

   class general_storage_order

   {

   public:

     typedef detail::multi_array::size_type size_type;

     template <typename OrderingIter, typename AscendingIter>

     general_storage_order(OrderingIter ordering,

                           AscendingIter ascending) {

       boost::detail::multi_array::copy_n(ordering,NumDims,ordering_.begin());

       boost::detail::multi_array::copy_n(ascending,NumDims,ascending_.begin());

     }

     // RG - ideally these would not be necessary, but some compilers

     // don't like template conversion operators.  I suspect that not

     // too many folk will feel the need to use customized

     // storage_order objects, I sacrifice that feature for compiler support.

     general_storage_order(const c_storage_order&) {

       for (size_type i=0; i != NumDims; ++i) {

         ordering_[i] = NumDims - 1 - i;

       }

       ascending_.assign(true);

     }

     general_storage_order(const fortran_storage_order&) {

       for (size_type i=0; i != NumDims; ++i) {

         ordering_[i] = i;

       }

       ascending_.assign(true);

     }

     size_type ordering(size_type dim) const { return ordering_[dim]; }

     bool ascending(size_type dim) const { return ascending_[dim]; }

     bool all_dims_ascending() const {

       return std::accumulate(ascending_.begin(),ascending_.end(),true,

                       std::logical_and<bool>());

     }

     bool operator==(general_storage_order const& rhs) const {

       return (ordering_ == rhs.ordering_) &&

         (ascending_ == rhs.ascending_);

     }

   protected:

     boost::array<size_type,NumDims> ordering_;

     boost::array<bool,NumDims> ascending_;

   };

   class c_storage_order 

   {

     typedef detail::multi_array::size_type size_type;

   public:

     // This is the idiom for creating your own custom storage orders.

     // Not supported by all compilers though!

 #ifndef __MWERKS__ // Metrowerks screams "ambiguity!"

     template <std::size_t NumDims>

     operator general_storage_order<NumDims>() const {

       boost::array<size_type,NumDims> ordering;

       boost::array<bool,NumDims> ascending;

       for (size_type i=0; i != NumDims; ++i) {

         ordering[i] = NumDims - 1 - i;

         ascending[i] = true;

       }

       return general_storage_order<NumDims>(ordering.begin(),

                                             ascending.begin());

     }

 #endif

   };

   class fortran_storage_order

   {

     typedef detail::multi_array::size_type size_type;

   public:

     // This is the idiom for creating your own custom storage orders.

     // Not supported by all compilers though! 

 #ifndef __MWERKS__ // Metrowerks screams "ambiguity!"

     template <std::size_t NumDims>

     operator general_storage_order<NumDims>() const {

       boost::array<size_type,NumDims> ordering;

       boost::array<bool,NumDims> ascending;

       for (size_type i=0; i != NumDims; ++i) {

         ordering[i] = i;

         ascending[i] = true;

       }

       return general_storage_order<NumDims>(ordering.begin(),

                                             ascending.begin());

     }

 #endif

   };

 } // namespace boost

 #endif // BOOST_ARRAY_STORAGE_RG071801_HPP