TreePath.hpp

#pragma once

#include <cassert>
#include <sstream>
#include <string>
#include <type_traits>

#include <dune/common/version.hh>
#include <dune/common/std/apply.hh>
#include <dune/typetree/treepath.hh>
#include <dune/typetree/typetraits.hh>

#include <amdis/common/Apply.hpp>
#include <amdis/common/Literals.hpp>
#include <amdis/common/Logical.hpp>

namespace AMDiS {

using RootTreePath = Dune::TypeTree::HybridTreePath<>;

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>...>
  {};

} // end namespace Definition

template <class TP>
constexpr bool PreTreePath = Dune::TypeTree::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>
  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>
  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>
auto makeTreePath(PreTreePath tp);

#else // DOXYGEN

template <class... Indices>
auto makeTreePath(Indices... ii)
  -> decltype( Dune::TypeTree::hybridTreePath(Impl::treePathIndex(ii)...) )
{
  return Dune::TypeTree::hybridTreePath(Impl::treePathIndex(ii)...);
}

inline auto makeTreePath()
{
  return Dune::TypeTree::hybridTreePath();
}

template <class Index, Index... I>
auto makeTreePath(std::integer_sequence<Index, I...>)
{
  return makeTreePath(std::integral_constant<std::size_t, std::size_t(I)>{}...);
}

template <class... T>
auto makeTreePath(std::tuple<T...> const& tp)
{
  return std::apply([](auto... ii) { return makeTreePath(ii...); }, tp);
}

template <class... T>
auto const& makeTreePath(Dune::TypeTree::HybridTreePath<T...> const& tp)
{
  return tp;
}

template <std::size_t... I>
auto makeTreePath(Dune::TypeTree::TreePath<I...>)
{
  return Dune::TypeTree::hybridTreePath(std::integral_constant<std::size_t, I>{}...);
}

#endif // DOXYGEN


template <char... digits>
constexpr auto operator"" _tp()
{
  return Dune::TypeTree::hybridTreePath(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::HybridTreePath<T...> const& tp)
{
  auto entry = [&](auto i) { return std::to_string(std::size_t(Dune::TypeTree::treePathEntry<i>(tp))); };
  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::HybridTreePath<> const&)
{
  return "";
}

// convert a treepath into an array
template <class... T>
auto to_array(Dune::TypeTree::HybridTreePath<T...> const& tp)
{
  return Ranges::applyIndices<sizeof...(T)>([&](auto... i) {
    return std::array<std::size_t,sizeof...(T)>{std::size_t(Dune::TypeTree::treePathEntry<i>(tp))...};
  });
}

template <class T0, class... T>
auto pop_front(Dune::TypeTree::HybridTreePath<T0,T...> const& tp)
{
  return Ranges::applyIndices<sizeof...(T)>([&](auto... i) {
    return Dune::TypeTree::hybridTreePath(Dune::TypeTree::treePathEntry<i+1>(tp)...);
  });
}

template <class... T, class TN>
auto pop_back(Dune::TypeTree::HybridTreePath<T...,TN> const& tp)
{
  return Ranges::applyIndices<sizeof...(T)>([&](auto... i) {
    return Dune::TypeTree::hybridTreePath(Dune::TypeTree::treePathEntry<i>(tp)...);
  });
}

template <class... S, class... T>
auto cat(Dune::TypeTree::HybridTreePath<S...> const& tp0, Dune::TypeTree::HybridTreePath<T...> const& tp1)
{
  return Dune::TypeTree::HybridTreePath<S...,T...>(std::tuple_cat(tp0._data,tp1._data));
}

} // end namespace AMDiS