layout_left.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_COMMON_STD_LAYOUT_LEFT_HH
#define DUNE_COMMON_STD_LAYOUT_LEFT_HH
 
#include <array>
#include <type_traits>
 
#include <dune/common/indices.hh>
#include <dune/common/std/no_unique_address.hh>
#include <dune/common/std/impl/fwd_layouts.hh>
 
namespace Dune::Std {
 
template <class Extents>
class layout_left::mapping
{
  template <class> friend class mapping;
 
public:
  using extents_type = Extents;
  using size_type = typename extents_type::size_type;
  using rank_type = typename extents_type::rank_type;
  using index_type = typename extents_type::index_type;
  using layout_type = layout_left;
 
  constexpr mapping () noexcept = default;
 
  constexpr mapping (const mapping&) noexcept = default;
 
  constexpr mapping (const extents_type& e) noexcept
    : extents_(e)
  {}
 
  template <class OtherExtents,
    std::enable_if_t<std::is_constructible_v<extents_type, OtherExtents>, int> = 0>
  #if __cpp_conditional_explicit >= 201806L
  explicit(!std::is_convertible_v<OtherExtents, extents_type>)
  #endif
  constexpr mapping (const mapping<OtherExtents>& m) noexcept
    : extents_(m.extents())
  {}
 
  template <class OtherExtents, class E = extents_type,
    std::enable_if_t<(E::rank() <= 1), int> = 0,
    std::enable_if_t<std::is_constructible_v<extents_type, OtherExtents>, int> = 0>
  #if __cpp_conditional_explicit >= 201806L
  explicit(!std::is_convertible_v<OtherExtents, extents_type>)
  #endif
  constexpr mapping (const layout_right::mapping<OtherExtents>& m) noexcept
    : extents_(m.extents())
  {}
 
  template <class OtherExtents,
    std::enable_if_t<std::is_constructible_v<extents_type, OtherExtents>, int> = 0>
  #if __cpp_conditional_explicit >= 201806L
  explicit(extents_type::rank() > 0)
  #endif
  constexpr mapping (const layout_stride::mapping<OtherExtents>& m)
    : extents_(m.extents())
  {
#ifndef NDEBUG
    if constexpr(extents_type::rank() > 0) {
      index_type prod = 1;
      for (rank_type r = 0; r < extents_type::rank()-1; ++r) {
        assert(m.strides(r) == prod);
        prod *= m.extents().extent(r);
      }
      assert(m.strides(extents_type::rank()-1) == prod);
    }
#endif
  }
 
  constexpr mapping& operator= (const mapping&) noexcept = default;
 
  constexpr const extents_type& extents () const noexcept { return extents_; }
  constexpr index_type required_span_size () const noexcept { return extents_.product(); }
 
  template <class... Indices,
    std::enable_if_t<(sizeof...(Indices) == extents_type::rank()), int> = 0,
    std::enable_if_t<(... && std::is_convertible_v<Indices, index_type>), int> = 0,
    std::enable_if_t<(... && std::is_nothrow_constructible_v<Indices, index_type>), int> = 0>
  constexpr index_type operator() (Indices... ii) const noexcept
  {
    const std::array indices{index_type(std::move(ii))...};
    index_type value = indices.back();
    for (rank_type r = 1; r < extents_type::rank(); ++r) {
      const rank_type j = extents_type::rank()-r;
      value = indices[j-1] + extents_.extent(j-1) * value;
    }
    return value;
  }
 
  constexpr index_type operator() () const noexcept
  {
    return 0;
  }
 
  static constexpr bool is_always_unique () noexcept { return true; }
  static constexpr bool is_always_exhaustive () noexcept { return true; }
  static constexpr bool is_always_strided () noexcept { return true; }
 
  static constexpr bool is_unique () noexcept { return true; }
  static constexpr bool is_exhaustive () noexcept { return true; }
  static constexpr bool is_strided () noexcept { return true; }
 
  template <class E = extents_type,
    std::enable_if_t<(E::rank() > 0), int> = 0>
  constexpr index_type stride (rank_type i) const noexcept
  {
    assert(i < extents_type::rank());
    index_type prod = 1;
    for (rank_type r = 0; r < i; ++r)
      prod *= extents().extent(r);
    return prod;
  }
 
  template <class OtherExtents,
    std::enable_if_t<(Extents::rank() == OtherExtents::rank()), int> = 0>
  friend constexpr bool operator== (const mapping& a, const mapping<OtherExtents>& b) noexcept
  {
    return a.extents_ == b.extents_;
  }
 
private:
  DUNE_NO_UNIQUE_ADDRESS extents_type extents_;
};
 
} // end namespace Dune::Std
 
#endif // DUNE_COMMON_STD_LAYOUT_LEFT_HH