// 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