TreePath.hpp

#pragma once

#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/Logical.hpp>

namespace AMDiS
{
  struct RootTreePath {};

  namespace Concepts
  {
    /** \addtogroup 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 <>
      struct IsPreTreePath<RootTreePath>
        : std::true_type
      {};

    } // 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

  /// \brief Converts a sequence of indices into a HybridTreePath
  /**
   * Converts an integer, an integralconstant, a sequence of those, or a TreePath
   * into an \ref Dune::TypeTree::HybridTreePath that is used in GlobalBasis traversal.
   *
   * **Requirements:**
   * The arguments can be one or more of
   * - integer type (`int, std::size_t`)
   * - integral constant (`std::integral_constant<[int|std::size_t],i>, index_t<i>`)
   * or one of dune treepath types, e.g.
   * - any Dune TreePath (`TreePath<std::size_t...>, HybridTreePath<class... T>`)
   * - a `std::tuple` type
   *
   * **Example:**
   * ```
   * makeTreePath(0,1,2),
   * makeTreePath(int_<2>, 0),
   * makeTreePath(1, index_<2>),
   * makeTreePath(hybridTreePath(0,1,2)),
   * makeTreePath(std::tuple{0,index_<2>,2})
   * ```
   **/
  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();
  }

  inline auto makeTreePath(RootTreePath)
  {
    return makeTreePath();
  }

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

#if DUNE_VERSION_LT(DUNE_TYPETREE,2,7)
  template <std::size_t... I>
  auto makeTreePath(Dune::TypeTree::TreePath<I...>)
  {
    return Dune::TypeTree::hybridTreePath(std::integral_constant<std::size_t, I>{}...);
  }
#else
  template <std::size_t... I>
  auto makeTreePath(Dune::TypeTree::StaticTreePath<I...>)
  {
    return Dune::TypeTree::hybridTreePath(std::integral_constant<std::size_t, I>{}...);
  }
#endif

#endif // DOXYGEN


  namespace Impl
  {
    template <class TreePath, std::size_t... I>
    void printTreePath(std::ostream& os, TreePath const& tp, std::index_sequence<I...>)
    {
      (void)std::initializer_list<int>{
        ((void)(os << treePathIndex(tp, std::integral_constant<std::size_t, I>{}) << ","), 0)...
      };
    }
  }

  template <class T0, class... T>
  std::string to_string(Dune::TypeTree::HybridTreePath<T0,T...> const& tp)
  {
    std::stringstream ss;
    Impl::printTreePath(ss, tp, std::make_index_sequence<sizeof...(T)>{});
    ss << Dune::TypeTree::treePathEntry<sizeof...(T)>(tp);
    return ss.str();
  }

  inline std::string to_string(Dune::TypeTree::HybridTreePath<> const&)
  {
    return "";
  }

  namespace Impl
  {
    template <class TreePath, std::size_t... I>
    std::array<std::size_t, sizeof...(I)> toArrayImpl(TreePath const& tp, std::index_sequence<I...>)
    {
      return {{std::size_t(Dune::TypeTree::treePathEntry<I>(tp))...}};
    }
  }

  template <class T0, class... T>
  auto to_array(Dune::TypeTree::HybridTreePath<T0,T...> const& tp)
  {
    return Impl::toArrayImpl(tp, std::make_index_sequence<1+sizeof...(T)>{});
  }

  inline std::array<std::size_t,1> to_array(Dune::TypeTree::HybridTreePath<> const&)
  {
    return {{0u}};
  }


  namespace Impl
  {
    template <class TreePath, std::size_t... I>
    auto popFrontImpl(TreePath const& tp, std::index_sequence<I...>)
    {
      return Dune::TypeTree::hybridTreePath(Dune::TypeTree::treePathEntry<I+1>(tp)...);
    }

    template <class TreePath, std::size_t... I>
    auto popBackImpl(TreePath const& tp, std::index_sequence<I...>)
    {
      return Dune::TypeTree::hybridTreePath(Dune::TypeTree::treePathEntry<I>(tp)...);
    }
  }

  template <class T0, class... T>
  Dune::TypeTree::HybridTreePath<T...> pop_front(Dune::TypeTree::HybridTreePath<T0,T...> const& tp)
  {
    return Impl::popFrontImpl(tp, std::make_index_sequence<sizeof...(T)>{});
  }

  template <class... T, class TN>
  Dune::TypeTree::HybridTreePath<T...> pop_front(Dune::TypeTree::HybridTreePath<T...,TN> const& tp)
  {
    return Impl::popBackImpl(tp, std::make_index_sequence<sizeof...(T)>{});
  }

  template <class... S, class... T>
  Dune::TypeTree::HybridTreePath<S...,T...> 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