utility.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_UTILITY_HH
#define DUNE_TYPETREE_UTILITY_HH
 
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <dune/common/shared_ptr.hh>
#include <dune/common/indices.hh>
#include <dune/typetree/nodeinterface.hh>
#include <dune/typetree/nodetags.hh>
 
namespace Dune {
  namespace TypeTree {
 
#ifndef DOXYGEN
 
    template<typename T>
    std::shared_ptr<T> convert_arg(const T& t)
    {
      return std::make_shared<T>(t);
    }
 
    template<typename T>
    std::shared_ptr<T> convert_arg(T& t)
    {
      return stackobject_to_shared_ptr(t);
    }
 
    template<typename BaseType, typename T>
    T& assertGridViewType(T& t)
    {
      static_assert((std::is_same<typename BaseType::Traits::GridViewType,
                     typename T::Traits::GridViewType>::value),
                    "GridViewType must be equal in all components of composite type");
      return t;
    }
 
    // only bind to real rvalues
    template<typename T>
    typename std::enable_if<!std::is_lvalue_reference<T>::value,std::shared_ptr<T> >::type convert_arg(T&& t)
    {
      return std::make_shared<T>(std::forward<T>(t));
    }
 
#endif // DOXYGEN
 
 
    template<typename Tree, typename Tag = StartTag>
    struct TreeInfo
    {
 
    private:
      // Start the tree traversal
      typedef TreeInfo<Tree,NodeTag<Tree>> NodeInfo;
 
    public:
 
      static const std::size_t depth = NodeInfo::depth;
 
      static const std::size_t nodeCount = NodeInfo::nodeCount;
 
      static const std::size_t leafCount = NodeInfo::leafCount;
 
    };
 
 
#ifndef DOXYGEN
 
    // ********************************************************************************
    // TreeInfo specializations for the different node types
    // ********************************************************************************
 
 
    // leaf node
    template<typename Node>
    struct TreeInfo<Node,LeafNodeTag>
    {
 
      static const std::size_t depth = 1;
 
      static const std::size_t nodeCount = 1;
 
      static const std::size_t leafCount = 1;
 
    };
 
 
    // power node - exploit the fact that all children are identical
    template<typename Node>
    struct TreeInfo<Node,PowerNodeTag>
    {
 
      typedef TreeInfo<typename Node::ChildType,NodeTag<typename Node::ChildType>> ChildInfo;
 
      static const std::size_t depth = 1 + ChildInfo::depth;
 
      static const std::size_t nodeCount = 1 + StaticDegree<Node>::value * ChildInfo::nodeCount;
 
      static const std::size_t leafCount = StaticDegree<Node>::value * ChildInfo::leafCount;
 
    };
 
 
    namespace {
 
      // TMP for iterating over the children of a composite node
      // identical for both composite node implementations
      template<typename Node, std::size_t k, std::size_t n>
      struct generic_compositenode_children_info
      {
 
        typedef generic_compositenode_children_info<Node,k+1,n> NextChild;
 
        // extract child info
        typedef typename Node::template Child<k>::Type Child;
        typedef NodeTag<Child> ChildTag;
        typedef TreeInfo<Child,ChildTag> ChildInfo;
 
        // combine information of current child with info about following children
        static const std::size_t maxDepth = ChildInfo::depth > NextChild::maxDepth ? ChildInfo::depth : NextChild::maxDepth;
 
        static const std::size_t nodeCount = ChildInfo::nodeCount + NextChild::nodeCount;
 
        static const std::size_t leafCount = ChildInfo::leafCount + NextChild::leafCount;
 
      };
 
      // End of recursion
      template<typename Node, std::size_t n>
      struct generic_compositenode_children_info<Node,n,n>
      {
        static const std::size_t maxDepth = 0;
 
        static const std::size_t nodeCount = 0;
 
        static const std::size_t leafCount = 0;
      };
 
    } // anonymous namespace
 
 
      // Struct for building information about composite node
    template<typename Node>
    struct GenericCompositeNodeInfo
    {
 
      typedef generic_compositenode_children_info<Node,0,StaticDegree<Node>::value> Children;
 
      static const std::size_t depth = 1 + Children::maxDepth;
 
      static const std::size_t nodeCount = 1 + Children::nodeCount;
 
      static const std::size_t leafCount = Children::leafCount;
 
    };
 
 
    // CompositeNode: delegate to GenericCompositeNodeInfo
    template<typename Node>
    struct TreeInfo<Node,CompositeNodeTag>
      : public GenericCompositeNodeInfo<Node>
    {};
 
 
#endif // DOXYGEN
 
 
    using Dune::index_constant;
    namespace Indices = Dune::Indices;
 
    template<typename... Args>
    void discard(Args&&... args)
    {}
 
    namespace apply_to_tuple_policy {
 
      struct no_pass_index {};
 
      struct pass_index {};
 
      typedef no_pass_index default_policy;
 
    }
 
    namespace {
 
      // version that does not pass index
      template<typename T, typename F, std::size_t... i>
      void _apply_to_tuple(T&& t, F&& f, std::index_sequence<i...>,apply_to_tuple_policy::no_pass_index)
      {
        discard((f(std::get<i>(std::forward<T>(t))),0)...);
      }
 
      // version that passes index
      template<typename T, typename F, std::size_t... i>
      void _apply_to_tuple(T&& t, F&& f, std::index_sequence<i...>,apply_to_tuple_policy::pass_index)
      {
        discard((f(index_constant<i>{},std::get<i>(std::forward<T>(t))),0)...);
      }
 
    }
 
    /*
     * This function applies the functor f to each element of the std::tuple t.
     * It works for arbitrary combinations of const- and non const lvalues and rvalues.
     * The function accepts an optional policy argument that can currently be used to make
     * it pass the index of the current tuple argument to the functor as a compile time constant
     * in addition to the tuple element itself.
     */
    template<typename T, typename F, typename Policy>
    void apply_to_tuple(T&& t, F&& f, Policy = apply_to_tuple_policy::default_policy())
    {
      const std::size_t size = std::tuple_size<typename std::decay<T>::type>::value;
      _apply_to_tuple(
        std::forward<T>(t),
        std::forward<F>(f),
        std::make_index_sequence<size>{},
        Policy()
        );
    }
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_UTILITY_HH