flatarray.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_ASSEMBLER_BACKEND_FLATARRAY_HH
#define DUNE_ASSEMBLER_BACKEND_FLATARRAY_HH
 
#include <array>
 
#include <dune/common/std/layout_right.hh>
#include <dune/common/std/mdarray.hh>
 
namespace Dune::Assembler {
 
template <class T, std::size_t...>
class FlatArray;
 
template <class T, std::size_t N>
class FlatArray<T,N>
  : public Std::mdarray<T, Std::extents<std::size_t,N>, Std::layout_right, std::array<T,N>>
{
  using Base = Std::mdarray<T, Std::extents<std::size_t,N>, Std::layout_right, std::array<T,N>>;
 
public:
  using index_type = typename Base::index_type;
  using value_type = typename Base::value_type;
  using extents_type = typename Base::extents_type;
 
  using Base::Base;
 
  explicit constexpr FlatArray (const value_type& value)
    : Base(extents_type{}, value)
  {}
 
  constexpr FlatArray& operator= (const value_type& value)
  {
    for (index_type i = 0; i < size(); ++i)
      (*this)[i] = value;
    return *this;
  }
 
  static constexpr index_type size () noexcept { return Base::static_extent(0); }
};
 
 
template <class T, std::size_t R, std::size_t C>
class FlatArray<T,R,C>
  : public Std::mdarray<T, Std::extents<std::size_t,R,C>, Std::layout_right, std::array<T,R*C>>
{
  using Base = Std::mdarray<T, Std::extents<std::size_t,R,C>, Std::layout_right, std::array<T,R*C>>;
 
public:
 
  using index_type = typename Base::index_type;
  using value_type = typename Base::value_type;
  using extents_type = typename Base::extents_type;
 
private:
  template <class Self>
  struct BracketProxy
  {
    constexpr auto& operator[] (index_type j) const { return (*self_)(i_,j); }
    Self* self_;
    index_type i_;
  };
 
public:
  using Base::Base;
 
  explicit constexpr FlatArray (const value_type& value)
    : Base(extents_type{}, value)
  {}
 
  constexpr FlatArray& operator= (const value_type& value)
  {
    for (index_type i = 0; i < rows(); ++i)
      for (index_type j = 0; j < cols(); ++j)
        (*this)[i][j] = value;
    return *this;
  }
 
  constexpr BracketProxy<const FlatArray> operator[] (index_type i) const { return {this,i}; }
  constexpr BracketProxy<FlatArray> operator[] (index_type i) { return {this,i}; }
 
  static constexpr index_type rows () noexcept { return Base::static_extent(0); }
  static constexpr index_type cols () noexcept { return Base::static_extent(1); }
};
 
} // end namespace Dune::Assembler
 
#endif // DUNE_ASSEMBLER_BACKEND_FLATARRAY_HH