TreePath.hpp

#pragma once

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

#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 TP>
      struct IsPreTreePath
        : std::is_integral<TP>
      {};

      template <int I>
      struct IsPreTreePath<std::integral_constant<int, I>>
        : std::true_type
      {};

      template <std::size_t I>
      struct IsPreTreePath<std::integral_constant<std::size_t, I>>
        : std::true_type
      {};

      template <int... I>
      struct IsPreTreePath<std::integer_sequence<int, I...>>
        : std::true_type
      {};

      template <std::size_t... I>
      struct IsPreTreePath<std::index_sequence<I...>>
        : std::true_type
      {};

      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

#ifdef DOXYGEN

  /// \brief Converts a (pre)TreePath into a HybridTreePath
  /**
   * Converts an integer, an integralconstant or a Dune TreePath into an
   * \ref Dune::TypeTree::HybridTreePath that is used in GlobalBasis traversal.
   *
   * **Requirements:**
   * - `PreTreePath` one of
   *     + integer type (`int, std::size_t`),
   *     + integral constant (`std::integral_constant<[int|std::size_t], i>`)
   *     + any Dune TreePath (`TreePath<std::size_t...>, DynamicTreePath, HybridTreePath<class... T>`)
   *
   * **Example:**
   * ```
   * makeTreePath(1),
   * makeTreePath(int_<2>),
   * makeTreePath(treepath(1, int_<2>))
   * ```
   **/
  template <class PreTreePath>
  auto makeTreePath(PreTreePath tp);

#else // DOXYGEN

  inline auto makeTreePath(int i)         { return Dune::TypeTree::hybridTreePath(std::size_t(i)); }
  inline auto makeTreePath(std::size_t i) { return Dune::TypeTree::hybridTreePath(i); }
  inline auto makeTreePath(RootTreePath)  { return Dune::TypeTree::hybridTreePath(); }


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

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

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

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


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

  template <class TP>
  auto makeTreePath(TP const&)
  {
    static_assert( Concepts::PreTreePath<TP>,
      "Argument must be a valid treepath, or an integer/index-constant");
    return Dune::TypeTree::hybridTreePath();
  }

#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& tp)
  {
    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& tp)
  {
    return {{0u}};
  }

  /// \brief Generate a TreePath from a sequence of integers and integral-constants
  /**
   * Converts a sequence of arguments to a \ref Dune::TypeTree::HybridTreePath.
   * The arguments can be one of
   * - integer type (`int, std::size_t`)
   * - integral constant (`std::integral_constant<std::size_t,i>, index_t<i>`)
   **/
  template <class... T>
  constexpr Dune::TypeTree::HybridTreePath<T...> treepath(T const&... t)
  {
    return Dune::TypeTree::HybridTreePath<T...>(t...);
  }


  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