treepath.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_TREEPATH_HH
#define DUNE_TYPETREE_TREEPATH_HH
 
#include <cstddef>
#include <iostream>
 
#include <dune/common/documentation.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/indices.hh>
#include <dune/common/hybridutilities.hh>
 
#include <dune/typetree/fixedcapacitystack.hh>
#include <dune/typetree/utility.hh>
 
 
namespace Dune {
  namespace TypeTree {
 
    template<typename... T>
    class HybridTreePath;
 
 
    namespace TreePathType {
      enum Type { fullyStatic, dynamic };
    }
 
    template<typename>
    struct TreePathSize;
 
    template<typename,std::size_t>
    struct TreePathPushBack;
 
    template<typename,std::size_t>
    struct TreePathPushFront;
 
    template<typename>
    struct TreePathBack;
 
    template<typename>
    struct TreePathFront;
 
    template<typename, std::size_t...>
    struct TreePathPopBack;
 
    template<typename>
    struct TreePathPopFront;
 
    template<typename, typename>
    struct TreePathConcat;
 
    template<std::size_t... i>
    void print_tree_path(std::ostream& os)
    {}
 
    template<std::size_t k, std::size_t... i>
    void print_tree_path(std::ostream& os)
    {
      os << k << " ";
      print_tree_path<i...>(os);
    }
 
 
    template<typename... T>
    class HybridTreePath
    {
 
    public:
 
      using index_sequence = std::index_sequence_for<T...>;
 
      constexpr HybridTreePath()
      {}
 
      constexpr HybridTreePath(const HybridTreePath& tp) = default;
      constexpr HybridTreePath(HybridTreePath&& tp) = default;
 
      constexpr HybridTreePath& operator=(const HybridTreePath& tp) = default;
      constexpr HybridTreePath& operator=(HybridTreePath&& tp) = default;
 
      explicit constexpr HybridTreePath(std::tuple<T...> t)
        : _data(t)
      {}
 
      template<typename... U, typename std::enable_if<(sizeof...(T) > 0 && sizeof...(U) == sizeof...(T)),bool>::type = true>
      explicit constexpr HybridTreePath(U... t)
        : _data(t...)
      {}
 
      constexpr static index_sequence enumerate()
      {
        return {};
      }
 
      constexpr static std::size_t size()
      {
        return sizeof...(T);
      }
 
      template<std::size_t i>
      constexpr auto operator[](Dune::index_constant<i>) const
      {
        return std::get<i>(_data);
      }
 
      constexpr std::size_t operator[](std::size_t pos) const
      {
        std::size_t entry = 0;
        Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
            if (i==pos)
              entry = this->element(i);
        });
        return entry;
      }
 
      template<std::size_t i>
      constexpr auto element(Dune::index_constant<i> pos = {}) const
      {
        return std::get<i>(_data);
      }
 
      constexpr std::size_t element(std::size_t pos) const
      {
        std::size_t entry = 0;
        Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
            if (i==pos)
              entry = this->element(i);
        });
        return entry;
      }
 
      auto back() const
      {
        return std::get<sizeof...(T)-1>(_data);
      }
 
#ifndef DOXYGEN
 
      // I can't be bothered to make all the external accessors friends of HybridTreePath,
      // so we'll only hide the data tuple from the user in Doxygen.
 
      using Data = std::tuple<T...>;
      Data _data;
 
#endif // DOXYGEN
 
    };
 
 
 
    template<typename... T>
    constexpr HybridTreePath<T...> hybridTreePath(const T&... t)
    {
      return HybridTreePath<T...>(t...);
    }
 
 
    template<typename... T>
    constexpr HybridTreePath<T...> treePath(const T&... t)
    {
      return HybridTreePath<T...>(t...);
    }
 
 
    template<typename... T>
    constexpr std::size_t treePathSize(const HybridTreePath<T...>&)
    {
      return sizeof...(T);
    }
 
 
    template<std::size_t i, typename... T>
    constexpr auto treePathEntry(const HybridTreePath<T...>& tp, index_constant<i> = {})
      -> typename std::decay<decltype(std::get<i>(tp._data))>::type
    {
      return std::get<i>(tp._data);
    }
 
 
    template<std::size_t i,typename... T>
    constexpr std::size_t treePathIndex(const HybridTreePath<T...>& tp, index_constant<i> = {})
    {
      return std::get<i>(tp._data);
    }
 
 
    template<typename... T, typename std::enable_if<(sizeof...(T) > 0),bool>::type = true>
    constexpr auto back(const HybridTreePath<T...>& tp)
      -> decltype(treePathEntry<sizeof...(T)-1>(tp))
    {
      return treePathEntry<sizeof...(T)-1>(tp);
    }
 
 
    template<typename... T>
    constexpr auto front(const HybridTreePath<T...>& tp)
      -> decltype(treePathEntry<0>(tp))
    {
      return treePathEntry<0>(tp);
    }
 
 
    template<typename... T>
    constexpr HybridTreePath<T...,std::size_t> push_back(const HybridTreePath<T...>& tp, std::size_t i)
    {
      return HybridTreePath<T...,std::size_t>(std::tuple_cat(tp._data,std::make_tuple(i)));
    }
 
 
    template<std::size_t i, typename... T>
    constexpr HybridTreePath<T...,index_constant<i>> push_back(const HybridTreePath<T...>& tp, index_constant<i> i_ = {})
    {
      return HybridTreePath<T...,index_constant<i> >(std::tuple_cat(tp._data,std::make_tuple(i_)));
    }
 
 
    template<typename... T>
    constexpr HybridTreePath<std::size_t,T...> push_front(const HybridTreePath<T...>& tp, std::size_t element)
    {
      return HybridTreePath<std::size_t,T...>(std::tuple_cat(std::make_tuple(element),tp._data));
    }
 
 
    template<std::size_t i, typename... T>
    constexpr HybridTreePath<index_constant<i>,T...> push_front(const HybridTreePath<T...>& tp, index_constant<i> _i = {})
    {
      return HybridTreePath<index_constant<i>,T...>(std::tuple_cat(std::make_tuple(_i),tp._data));
    }
 
 
    template <class... T>
    constexpr auto pop_front(const HybridTreePath<T...>& tp)
    {
      static_assert(sizeof...(T) != 0, "HybridTreePath must not be empty");
      return unpackIntegerSequence([&](auto... i){
        return HybridTreePath{std::make_tuple(std::get<i+1>(tp._data)...)};
      }, std::make_index_sequence<(sizeof...(T) - 1)>{});
    }
 
 
    template <class... T>
    constexpr auto pop_back(const HybridTreePath<T...>& tp)
    {
      static_assert(sizeof...(T) != 0, "HybridTreePath must not be empty");
      return unpackIntegerSequence([&](auto... i){
        return HybridTreePath{std::make_tuple(std::get<i>(tp._data)...)};
      }, std::make_index_sequence<(sizeof...(T) - 1)>{});
    }
 
 
    template <class... S, class... T>
    constexpr bool operator==(
      const HybridTreePath<S...>& lhs,
      const HybridTreePath<T...>& rhs)
    {
      if constexpr (sizeof...(S) == sizeof...(T)) {
        if constexpr ((Dune::IsInteroperable<S,T>::value &&...)) {
          return unpackIntegerSequence([&](auto... i){
            return ((std::get<i>(lhs._data) == std::get<i>(rhs._data)) &&...);
          }, std::make_index_sequence<(sizeof...(S))>{});
        } else {
          return false;
        }
      } else {
        return false;
      }
    }
 
 
    template <class S, S... lhs, class T, T... rhs>
    constexpr auto operator==(
      const HybridTreePath<std::integral_constant<S,lhs>...>&,
      const HybridTreePath<std::integral_constant<T,rhs>...>&)
    {
      return std::bool_constant<hybridTreePath(lhs...) == hybridTreePath(rhs...)>{};
    }
 
 
    template <class... S, class... T>
    constexpr auto operator!=(
      const HybridTreePath<S...>& lhs,
      const HybridTreePath<T...>& rhs)
    {
      return !(lhs == rhs);
    }
 
    template <class S, S... lhs, class T, T... rhs>
    constexpr auto operator!=(
      const HybridTreePath<std::integral_constant<S,lhs>...>&,
      const HybridTreePath<std::integral_constant<T,rhs>...>&)
    {
      return std::bool_constant<hybridTreePath(lhs...) != hybridTreePath(rhs...)>{};
    }
 
    template<std::size_t... i>
    struct TreePathSize<HybridTreePath<index_constant<i>...> >
      : public index_constant<sizeof...(i)>
    {};
 
 
    template<std::size_t k, std::size_t... i>
    struct TreePathPushBack<HybridTreePath<index_constant<i>...>,k>
    {
      typedef HybridTreePath<index_constant<i>...,index_constant<k>> type;
    };
 
    template<std::size_t k, std::size_t... i>
    struct TreePathPushFront<HybridTreePath<index_constant<i>...>,k>
    {
      typedef HybridTreePath<index_constant<k>,index_constant<i>...> type;
    };
 
    template<std::size_t k>
    struct TreePathBack<HybridTreePath<index_constant<k>>>
      : public index_constant<k>
    {};
 
    template<std::size_t j, std::size_t k, std::size_t... l>
    struct TreePathBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>>
      : public TreePathBack<HybridTreePath<index_constant<k>,index_constant<l>...>>
    {};
 
    template<std::size_t k, std::size_t... i>
    struct TreePathFront<HybridTreePath<index_constant<k>,index_constant<i>...>>
      : public index_constant<k>
    {};
 
    template<std::size_t k, std::size_t... i>
    struct TreePathPopBack<HybridTreePath<index_constant<k>>,i...>
    {
      typedef HybridTreePath<index_constant<i>...> type;
    };
 
    template<std::size_t j,
             std::size_t k,
             std::size_t... l,
             std::size_t... i>
    struct TreePathPopBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>,i...>
      : public TreePathPopBack<HybridTreePath<index_constant<k>,index_constant<l>...>,i...,j>
    {};
 
    template<std::size_t k, std::size_t... i>
    struct TreePathPopFront<HybridTreePath<index_constant<k>,index_constant<i>...> >
    {
      typedef HybridTreePath<index_constant<i>...> type;
    };
 
    template<std::size_t... i, std::size_t... k>
    struct TreePathConcat<HybridTreePath<index_constant<i>...>,HybridTreePath<index_constant<k>...> >
    {
      typedef HybridTreePath<index_constant<i>...,index_constant<k>...> type;
    };
 
#ifndef DOXYGEN
 
    namespace impl {
 
      // end of recursion
      template<std::size_t i, typename... T>
      typename std::enable_if<
        (i == sizeof...(T))
        >::type
      print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
      {}
 
      // print current entry and recurse
      template<std::size_t i, typename... T>
      typename std::enable_if<
        (i < sizeof...(T))
        >::type
      print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
      {
        os << treePathIndex(tp,_i) << " ";
        print_hybrid_tree_path(os,tp,index_constant<i+1>{});
      }
 
    } // namespace impl
 
#endif // DOXYGEN
 
    template<typename... T>
    std::ostream& operator<<(std::ostream& os, const HybridTreePath<T...>& tp)
    {
      os << "HybridTreePath< ";
      impl::print_hybrid_tree_path(os, tp, index_constant<0>{});
      os << ">";
      return os;
    }
 
    template<std::size_t... i>
    using TreePath [[deprecated("use StaticTreePath, this type will be removed after DUNE 2.7")]] = HybridTreePath<Dune::index_constant<i>...>;
 
    template<std::size_t... i>
    using StaticTreePath = HybridTreePath<Dune::index_constant<i>...>;
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_TREEPATH_HH