TreePath.hpp

#pragma once
 
#include <cassert>
#include <sstream>
#include <string>
#include <type_traits>
 
#include <dune/common/typetree/treepath.hh>
 
#include <amdis/common/Apply.hpp>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Literals.hpp>
#include <amdis/common/Logical.hpp>
 
namespace AMDiS {
 
using RootTreePath = Dune::TypeTree::TreePath<>;
 
namespace Concepts {
 
namespace Definition
{
  template <class Index>
  struct IsPreTreePath
    : std::is_integral<Index>
  {};
 
  template <class Index, Index I>
  struct IsPreTreePath<std::integral_constant<Index, I>>
    : std::is_integral<Index>
  {};
 
  template <class Index, Index... I>
  struct IsPreTreePath<std::integer_sequence<Index, I...>>
    : std::is_integral<Index>
  {};
 
  template <class... Indices>
  struct IsPreTreePath<std::tuple<Indices...>>
    : std::conjunction<std::is_integral<Indices>...>
  {};
 
  template <class TP>
  struct IsTreePath
    : std::false_type
  {};
 
  template <class... Indices>
  struct IsTreePath<Dune::TypeTree::TreePath<Indices...>>
    : std::true_type
  {};
 
} // end namespace Definition
 
template <class TP>
constexpr bool PreTreePath = Definition::IsTreePath<TP>::value || Definition::IsPreTreePath<TP>::value;
 
template <class TP>
using PreTreePath_t = bool_t<PreTreePath<TP>>;
 
} // end namespace Concepts
 
namespace Impl
{
  template <class Index,
    std::enable_if_t<std::is_integral_v<Index>, int> = 0>
  constexpr std::size_t treePathIndex(Index i)
  {
    return std::size_t(i);
  }
 
  template <class Index, Index i,
    std::enable_if_t<std::is_integral_v<Index>, int> = 0>
  constexpr auto treePathIndex(std::integral_constant<Index,i>)
  {
    return std::integral_constant<std::size_t,std::size_t(i)>{};
  }
 
} // end namespace Impl
 
#ifdef DOXYGEN
 
 
template <class PreTreePath>
constexpr auto makeTreePath(PreTreePath tp);
 
#else // DOXYGEN
 
template <class... Indices>
constexpr auto makeTreePath(Indices... ii)
  -> decltype( Dune::TypeTree::treePath(Impl::treePathIndex(ii)...) )
{
  return Dune::TypeTree::treePath(Impl::treePathIndex(ii)...);
}
 
constexpr auto makeTreePath()
{
  return Dune::TypeTree::treePath();
}
 
template <class Index, Index... I>
constexpr auto makeTreePath(std::integer_sequence<Index, I...>)
{
  return makeTreePath(std::integral_constant<std::size_t, std::size_t(I)>{}...);
}
 
template <class... T>
constexpr auto makeTreePath(std::tuple<T...> const& tp)
{
  return std::apply([](auto... ii) { return makeTreePath(ii...); }, tp);
}
 
template <class... T>
constexpr auto const& makeTreePath(Dune::TypeTree::TreePath<T...> const& tp)
{
  return tp;
}
 
template <std::size_t... I>
constexpr auto makeTreePath(Dune::TypeTree::TreePath<Dune::index_constant<I>...> tp)
{
  return tp;
}
 
#endif // DOXYGEN
 
 
template <char... digits>
constexpr auto operator"" _tp()
{
  return Dune::TypeTree::treePath(std::integral_constant<std::size_t,Impl::char2digit(digits)>{}...);
}
 
 
// convert a treepath into a string, comma-separated
template <class... T>
std::string to_string(Dune::TypeTree::TreePath<T...> const& tp)
{
  auto entry = [&](auto i) { return std::to_string(std::size_t(tp[i])); };
  auto first = [&] { return entry(std::integral_constant<std::size_t,0>()); };
 
  return Ranges::applyIndices<1,sizeof...(T)>([&](auto... i) -> std::string {
    return (first() +...+ ("," + entry(i)));
  });
}
 
inline std::string to_string(Dune::TypeTree::TreePath<> const&)
{
  return "";
}
 
// convert a treepath into an array
template <class... T>
auto to_array(Dune::TypeTree::TreePath<T...> const& tp)
{
  return Ranges::applyIndices<sizeof...(T)>([&](auto... i) {
    return std::array<std::size_t,sizeof...(T)>{std::size_t(tp[i])...};
  });
}
 
template <class T0, class... T>
auto pop_front(Dune::TypeTree::TreePath<T0,T...> const& tp)
{
  return Ranges::applyIndices<sizeof...(T)>([&](auto... i) {
    return Dune::TypeTree::treePath(tp[index_t<i+1>{}]...);
  });
}
 
template <class... T>
requires (sizeof...(T)>0)
auto pop_back(Dune::TypeTree::TreePath<T...> const& tp)
{
  return Ranges::applyIndices<sizeof...(T)-1>([&](auto... i) {
    return Dune::TypeTree::treePath(tp[i]...);
  });
}
 
template <class... S, class... T>
auto cat(Dune::TypeTree::TreePath<S...> const& tp0, Dune::TypeTree::TreePath<T...> const& tp1)
{
  return Dune::TypeTree::join(tp0, tp1);
}
 
template<class First, class Second, REQUIRES(Concepts::PreTreePath<First> and Concepts::PreTreePath<Second>)>
auto cat(First const& first, Second const& second)
{
  return cat(makeTreePath(first), makeTreePath(second));
}
 
} // end namespace AMDiS