visitor.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_VISITOR_HH
#define DUNE_TYPETREE_VISITOR_HH
 
#include <dune/typetree/treepath.hh>
#include <dune/typetree/utility.hh>
 
namespace Dune {
  namespace TypeTree {
 
 
    struct DefaultVisitor
    {
 
 
      template<typename T, typename TreePath>
      void pre(T&&, TreePath) const {}
 
 
      template<typename T, typename TreePath>
      void in(T&&, TreePath) const {}
 
 
      template<typename T, typename TreePath>
      void post(T&&, TreePath) const {}
 
 
      template<typename T, typename TreePath>
      void leaf(T&&, TreePath) const {}
 
 
      template<typename T, typename Child, typename TreePath, typename ChildIndex>
      void beforeChild(T&&, Child&&, TreePath, ChildIndex) const {}
 
 
      template<typename T, typename Child, typename TreePath, typename ChildIndex>
      void afterChild(T&&, Child&&, TreePath, ChildIndex) const {}
 
    };
 
 
 
    struct DefaultPairVisitor
    {
 
 
      template<typename T1, typename T2, typename TreePath>
      void pre(T1&&, T2&&, TreePath) const {}
 
 
      template<typename T1, typename T2, typename TreePath>
      void in(T1&&, T2&&, TreePath) const {}
 
 
      template<typename T1, typename T2, typename TreePath>
      void post(T1&&, T2&&, TreePath) const {}
 
 
      template<typename T1, typename T2, typename TreePath>
      void leaf(T1&&, T2&&, TreePath) const {}
 
 
      template<typename T1, typename Child1, typename T2, typename Child2, typename TreePath, typename ChildIndex>
      void beforeChild(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const {}
 
 
      template<typename T1, typename Child1, typename T2, typename Child2, typename TreePath, typename ChildIndex>
      void afterChild(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const {}
 
    };
 
 
    namespace Experimental {
 
      struct DefaultHybridVisitor
      {
 
        template<typename T, typename TreePath, typename U>
        auto pre(T&&, TreePath, const U& u) const { return u;}
 
        template<typename T, typename TreePath, typename U>
        auto in(T&&, TreePath, const U& u) const {return u;}
 
        template<typename T, typename TreePath, typename U>
        auto post(T&&, TreePath, const U& u) const {return u;}
 
        template<typename T, typename TreePath, typename U>
        auto leaf(T&&, TreePath, const U& u) const { return u;}
 
        template<typename T, typename Child, typename TreePath, typename ChildIndex, typename U>
        auto beforeChild(T&&, Child&&, TreePath, ChildIndex, const U& u) const {return u;}
 
        template<typename T, typename Child, typename TreePath, typename ChildIndex, typename U>
        auto afterChild(T&&, Child&&, TreePath, ChildIndex, const U& u) const {return u;}
 
      };
    } // namespace Experimental
 
 
    struct VisitDirectChildren
    {
 
      // the little trick with the default template arguments
      // makes the class usable for both single-tree visitors
      // and visitors for pairs of trees
      template<typename Node1,
               typename Child1,
               typename Node2,
               typename Child2 = void,
               typename TreePath = void>
      struct VisitChild
      {
        static const bool value = false;
      };
 
    };
 
 
 
    struct VisitTree
    {
 
      // the little trick with the default template arguments
      // makes the class usable for both single-tree visitors
      // and visitors for pairs of trees
      template<typename Node1,
               typename Child1,
               typename Node2,
               typename Child2 = void,
               typename TreePath = void>
      struct VisitChild
      {
        static const bool value = true;
      };
 
    };
 
 
    struct StaticTraversal
    {
      static const TreePathType::Type treePathType = TreePathType::fullyStatic;
    };
 
 
    struct DynamicTraversal
    {
      static const TreePathType::Type treePathType = TreePathType::dynamic;
    };
 
    struct TreeVisitor
      : public DefaultVisitor
      , public VisitTree
    {};
 
    struct DirectChildrenVisitor
      : public DefaultVisitor
      , public VisitDirectChildren
    {};
 
    struct TreePairVisitor
      : public DefaultPairVisitor
      , public VisitTree
    {};
 
    struct DirectChildrenPairVisitor
      : public DefaultPairVisitor
      , public VisitDirectChildren
    {};
 
    namespace Experimental::Info {
 
      struct LeafCounterVisitor
        : public DefaultHybridVisitor
        , public StaticTraversal
        , public VisitTree
      {
        template<class Tree, class Child, class TreePath, class ChildIndex, class U>
        auto beforeChild(Tree&&, Child&&, TreePath, ChildIndex, U u) const {
          // in this case child index is an integral constant: forward u
          return u;
        }
 
        template<class Tree, class Child, class TreePath, class U>
        std::size_t beforeChild(Tree&&, Child&&, TreePath, std::size_t /*childIndex*/, U u) const {
          // in this case child index is a run-time index: cast accumulated u to std::size_t
          return std::size_t{u};
        }
 
        template<class Tree, class TreePath, class U>
        auto leaf(Tree&&, TreePath, U u) const
        {
          return Hybrid::plus(u,Dune::Indices::_1);
        }
 
      };
 
      struct NodeCounterVisitor
        : public LeafCounterVisitor
      {
        template<typename Tree, typename TreePath, typename U>
        auto pre(Tree&&, TreePath, U u) const {
          return Hybrid::plus(u,Indices::_1);
        }
      };
 
      struct DepthVisitor
        : public DefaultHybridVisitor
        , public StaticTraversal
        , public VisitTree
      {
        template<class Tree, class TreePath, class U>
        auto leaf(Tree&&, TreePath, U u) const
        {
          auto path_size = index_constant<treePathSize(TreePath{})>{};
          auto depth = Hybrid::plus(path_size,Indices::_1);
          return Hybrid::max(depth,u);
        }
      };
 
    // result is alwayas an integral constant
      template<typename Tree>
      auto depth(const Tree& tree)
      {
        return hybridApplyToTree(tree,DepthVisitor{},Indices::_0);
      }
 
      // return types is std::integral_constant.
      template<typename Tree>
      constexpr auto depth()
      {
        return decltype(hybridApplyToTree(std::declval<Tree>(),DepthVisitor{},Indices::_0)){};
      }
 
      // if Tree is dynamic, return type is std::size_t, otherwise std::integral_constant.
      template<typename Tree>
      auto nodeCount(const Tree& tree)
      {
        return hybridApplyToTree(tree,NodeCounterVisitor{},Indices::_0);
      }
 
      // if Tree is dynamic, return type is std::size_t, otherwise std::integral_constant.
      template<typename Tree>
      auto leafCount(const Tree& tree)
      {
        return hybridApplyToTree(tree,LeafCounterVisitor{},Dune::Indices::_0);
      }
 
      template<typename Tree>
      constexpr bool isDynamic = std::is_same<std::size_t, decltype(leafCount(std::declval<Tree>()))>{};
 
    } // namespace Experimental::Info
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_VISITOR_HH