Utility.hpp

#pragma once

#include <list>
#include <map>
#include <memory>
#include <type_traits>
#include <vector>

#include <dune/amdis/common/Mpl.hpp>

namespace AMDiS
{
  // pull in std implementations
  using std::shared_ptr;
  using std::make_shared;

  using std::unique_ptr;
  using std::make_unique;

  // ---------------------------------------------------------------------------

  namespace Impl
  {
    // workaround for MSVC (problems with alias templates in pack expansion)
    template <class, class T>
    struct InvokeType { using type = T; };

    template <class, class, class T>
    struct InvokeType2 { using type = T; };

    template <class T>
    struct ValueType
    {
      using type = typename InvokeType<T, typename T::value_type>::type;
    };
  }

  template <class T>
  using Value_t = typename Impl::ValueType<T>::type;

  template <class T>
  using Size_t = typename Impl::InvokeType<T, typename T::size_type>::type;

  template <class T>
  using Result_t = typename Impl::InvokeType<T, typename T::result_type>::type;

  template <class T>
  using Decay_t = typename Impl::InvokeType<T, typename std::decay<T>::type>::type;

  template <class T1, class T2>
  using Common_t = typename Impl::InvokeType2<T1, T2, typename std::common_type<T1,T2>::type>::type;

  namespace Impl
  {
    template <class T>
    struct UnderlyingType
    {
      using type = T;
    };

    template <class T>
    struct UnderlyingType<std::reference_wrapper<T>>
    {
      using type = T;
    };
  }

  template <class T>
  using Underlying_t = typename Impl::UnderlyingType<T>::type;


  // ---------------------------------------------------------------------------


  /// A variadic type list
  template <class... Ts>
  struct Types {};

  template <class... Ts>
  using Types_t = Types<Decay_t<Ts>...>;


  /// An identity type wrapper, represents the type itself
  template <class T>
  struct Id
  {
    using type = T;
  };

  template <class T>
  using Id_t = typename Id<T>::type;


  /// Alias that indicates ownership of resources
  template <class T>
  using owner = T;

  /// Dummy type for unknown return type
  struct no_valid_type {};


  template <class F1, class F2>
  struct overloaded : F1, F2
  {
    overloaded(F1 x1, F2 x2)
      : F1(x1), F2(x2)
    {}

    using F1::operator();
    using F2::operator();
  };

  template <class F>
  F overload(F f) { return f; }

  template <class F1, class F2>
  overloaded<F1, F2> overload(F1 f1, F2 f2)
  {
    return {f1, f2};
  }

  template <class F1, class... Fs>
  auto overload(F1 f1, Fs... fs)
  {
    return overload(f1, overload(fs...));
  }

  // ---------------------------------------------------------------------------


  /// generalization of get<tuple>, get<array> for vectors
  template <std::size_t I, class T, class A>
  T const& get(std::vector<T,A> const& vec)
  {
      return vec[I];
  }


  // ---------------------------------------------------------------------------


  struct VectorComponent
  {
    std::size_t index;
  };

  struct MatrixComponent
  {
    std::size_t row;
    std::size_t col;
  };

} // end namespace AMDiS