storage_order.hpp

/*
 * storage_order.hpp
 *
 *  Created on: Jul 1, 2018
 *      Author: i-bird
 */
 
#ifndef STORAGE_ORDER_HPP_
#define STORAGE_ORDER_HPP_
 
#include "types.hpp"
#include "array_openfpm.hpp"
#include "boost/multi_array/algorithm.hpp"
#include <algorithm>
#include <cstddef>
#include <functional>
#include <numeric>
#include <vector>
 
namespace openfpm
{
 
class c_storage_order;
class fortran_storage_order;
class ofp_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());
  }
 
  // 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;
    }
  }
 
  general_storage_order(const fortran_storage_order&) {
    for (size_type i=0; i != NumDims; ++i) {
      ordering_[i] = i;
    }
  }
 
  general_storage_order(const ofp_storage_order&)
  {
        ordering_[0] = 0;
        for (size_type i=1; i != NumDims; ++i)
        {ordering_[i] = NumDims - i;}
  }
 
  size_type ordering(size_type dim) const { return ordering_[dim]; }
 
 
  bool operator==(general_storage_order const& rhs) const
  {
    return (ordering_ == rhs.ordering_);
  }
 
protected:
  openfpm::array<size_type,NumDims> ordering_;
};
 
class ofp_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
  {
    openfpm::array<size_type,NumDims> ordering;
 
    ordering[0] = 0;
    for (size_type i=1; i != NumDims; ++i)
    {ordering[i] = NumDims - i;}
    return general_storage_order<NumDims>(ordering.begin());
  }
#endif
};
 
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 {
    openfpm::array<size_type,NumDims> ordering;
    openfpm::array<bool,NumDims> ascending;
 
    for (size_type i=0; i != NumDims; ++i) {
      ordering[i] = NumDims - 1 - i;
    }
    return general_storage_order<NumDims>(ordering.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
  {
    openfpm::array<size_type,NumDims> ordering;
 
    for (size_type i=0; i != NumDims; ++i) {
      ordering[i] = i;
    }
    return general_storage_order<NumDims>(ordering.begin());
  }
#endif
};
 
} // namespace openfpm
 
 
#endif /* STORAGE_ORDER_HPP_ */