SerialAccess.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

// MOOSE includes
#include "Moose.h"
#include "MooseTypes.h"
#include "RankTwoTensorForward.h"
#include "RankFourTensorForward.h"

#include <tuple>

namespace Moose
{

template <typename T>
struct SerialAccess
{
  static_assert(always_false<T>, "Specialize SerialAccess for this type.");
};

// Specializations for scalar types
#define SERIAL_ACCESS_SCALAR(type)                                                                 \
  template <>                                                                                      \
  struct SerialAccess<type>                                                                        \
  {                                                                                                \
    static type * data(type & obj) { return &obj; }                                                \
    static constexpr std::size_t size(type &) { return 1u; }                                       \
    static constexpr std::size_t size() { return 1u; }                                             \
  }

SERIAL_ACCESS_SCALAR(Real);
SERIAL_ACCESS_SCALAR(const Real);
SERIAL_ACCESS_SCALAR(ADReal);
SERIAL_ACCESS_SCALAR(const ADReal);

// constant size containers
#define SERIAL_ACCESS_CONST_SIZE(type, dataptr, sizeval)                                           \
  template <typename T>                                                                            \
  struct SerialAccess<type<T>>                                                                     \
  {                                                                                                \
    static auto * data(type<T> & obj) { return dataptr; }                                          \
    static constexpr std::size_t size(type<T> &) { return sizeval; }                               \
    static constexpr std::size_t size() { return sizeval; }                                        \
  }

SERIAL_ACCESS_CONST_SIZE(libMesh::VectorValue, &obj(0u), Moose::dim);
SERIAL_ACCESS_CONST_SIZE(const libMesh::VectorValue, &obj(0u), Moose::dim);
SERIAL_ACCESS_CONST_SIZE(RankTwoTensorTempl, &obj(0u, 0u), RankTwoTensorTempl<T>::N2);
SERIAL_ACCESS_CONST_SIZE(const RankTwoTensorTempl, &obj(0u, 0u), RankTwoTensorTempl<T>::N2);
SERIAL_ACCESS_CONST_SIZE(RankFourTensorTempl, &obj(0u, 0u, 0u, 0u), RankFourTensorTempl<T>::N4);
SERIAL_ACCESS_CONST_SIZE(const RankFourTensorTempl,
                         &obj(0u, 0u, 0u, 0u),
                         RankFourTensorTempl<T>::N4);

// dynamic size containers (determining size requires an object instance)
#define SERIAL_ACCESS_DYNAMIC_SIZE(type, dataptr, sizeval)                                         \
  template <typename T>                                                                            \
  struct SerialAccess<type<T>>                                                                     \
  {                                                                                                \
    static auto * data(type<T> & obj) { return dataptr; }                                          \
    static constexpr std::size_t size(type<T> & obj) { return sizeval; }                           \
  }

SERIAL_ACCESS_DYNAMIC_SIZE(DenseVector, &obj(0u), obj.size());

template <typename T>
struct SerialAccessValueTypeHelper
{
  typedef typename T::value_type value_type;
};
template <>
struct SerialAccessValueTypeHelper<ADReal>
{
  typedef ADReal value_type;
};
template <>
struct SerialAccessValueTypeHelper<Real>
{
  typedef Real value_type;
};

template <typename T>
class SerialAccessRange
{
public:
  typedef typename SerialAccessValueTypeHelper<typename std::remove_const<T>::type>::value_type R;
  typedef typename std::conditional<std::is_const_v<T>, const R, R>::type V;

  class iterator
  {
  public:
    iterator(V * i) : _i(i) {}

    V & operator*() const { return *_i; }

    const iterator & operator++()
    {
      ++_i;
      return *this;
    }

    iterator operator++(int)
    {
      iterator returnval(*this);
      ++_i;
      return returnval;
    }

    bool operator==(const iterator & j) const { return (_i == j._i); }
    bool operator!=(const iterator & j) const { return !(*this == j); }

  private:
    V * _i;
  };

  SerialAccessRange(T & obj)
    : _begin(SerialAccess<T>::data(obj)),
      _end(SerialAccess<T>::data(obj) + SerialAccess<T>::size(obj))
  {
  }

  iterator begin() const { return _begin; }
  iterator end() const { return _end; }

  V & operator[](int i) { return *(&*_begin + i); }

private:
  iterator _begin, _end;
};

template <typename T>
SerialAccessRange<T>
serialAccess(T & obj)
{
  return SerialAccessRange<T>(obj);
}

template <typename... Ts>
struct TypeList
{
  typedef std::tuple<Ts...> Tuple;
  typedef std::tuple<Ts *...> PointerTuple;
  static constexpr std::size_t size = sizeof...(Ts);
};

template <template <typename, int> class L, int I, typename T, typename... Ts, typename... As>
void
typeLoopInternal(TypeList<T, Ts...>, As... args)
{
  L<T, I>::apply(args...);
  if constexpr (sizeof...(Ts) > 0)
    typeLoopInternal<L, I + 1>(TypeList<Ts...>{}, args...);
}

template <template <typename, int> class L, typename... Ts, typename... As>
void
typeLoop(TypeList<Ts...>, As... args)
{
  typeLoopInternal<L, 0>(TypeList<Ts...>{}, args...);
}

} // namespace Moose;