filteredcompositenode.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
#define DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
 
#include <memory>
#include <tuple>
#include <type_traits>
 
#include <dune/typetree/nodetags.hh>
#include <dune/typetree/filters.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/indices.hh>
 
#include <dune/typetree/filters.hh>
#include <dune/typetree/nodetags.hh>
 
namespace Dune {
  namespace TypeTree {
 
#ifndef DOXYGEN
    namespace {
 
      // ********************************************************************************
      // Utility structs for filter construction and application
      // ********************************************************************************
 
      // Gets the filter and wraps it in case of a SimpleFilter.
      template<typename Filter, typename Tag>
      struct get_filter;
 
      // Helper struct to extract the child template parameter pack from the ChildTypes tuple.
      template<typename Filter, typename Node, typename ChildTypes>
      struct apply_filter_wrapper;
 
      template<typename Filter, typename Node, typename... Children>
      struct apply_filter_wrapper<Filter,Node,std::tuple<Children...> >
        : public Filter::template apply<Node,Children...>
      {};
 
      // specialization for SimpleFilter
      template<typename Filter>
      struct get_filter<Filter,SimpleFilterTag>
      {
        struct type
        {
          template<typename Node, typename ChildTypes>
          struct apply
            : public apply_filter_wrapper<filter<Filter>,Node,ChildTypes>
          {};
        };
      };
 
      // specialization for AdvancedFilter
      template<typename Filter>
      struct get_filter<Filter,AdvancedFilterTag>
      {
        struct type
        {
          template<typename Node, typename ChildTypes>
          struct apply
            : public apply_filter_wrapper<Filter,Node,ChildTypes>
          {};
        };
      };
 
    } // anonymous namespace
#endif // DOXYGEN
 
 
    template<typename Node, typename Filter>
    class FilteredCompositeNode
    {
 
      typedef typename get_filter<Filter,typename Filter::FilterTag>::type filter;
      typedef typename filter::template apply<Node,typename Node::ChildTypes>::type filter_result;
      typedef typename filter_result::template apply<Node> mapped_children;
 
      static const bool nodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
 
      template<std::size_t k>
      struct lazy_enable
      {
        static const bool value = !nodeIsConst;
      };
 
    public:
 
      typedef CompositeNodeTag NodeTag;
 
      typedef typename mapped_children::NodeStorage NodeStorage;
 
      typedef typename mapped_children::ChildTypes ChildTypes;
 
      static const bool isLeaf = false;
 
      static const bool isPower = false;
 
      static const bool isComposite = true;
 
      static const std::size_t CHILDREN = filter_result::size;
 
      static constexpr auto degree ()
      {
        return std::integral_constant<std::size_t,filter_result::size>{};
      }
 
      template<std::size_t k>
      struct Child {
 
#ifndef DOXYGEN
 
        typedef typename std::tuple_element<k,typename mapped_children::Children>::type OriginalChild;
 
        static const std::size_t mapped_index = std::tuple_element<k,typename filter_result::IndexMap>::type::original_index;
 
#endif // DOXYGEN
 
        typedef typename OriginalChild::Type Type;
 
        typedef typename OriginalChild::type type;
      };
 
 
 
      template<std::size_t k,
        typename std::enable_if<lazy_enable<k>::value, int>::type = 0>
      auto& child (index_constant<k> = {})
      {
        return _node->template child<Child<k>::mapped_index>();
      }
 
 
      template<std::size_t k>
      const auto& child (index_constant<k> = {}) const
      {
        return _node->template child<Child<k>::mapped_index>();
      }
 
 
      template<std::size_t k,
        typename std::enable_if<lazy_enable<k>::value, int>::type = 0>
      auto childStorage (index_constant<k> = {})
      {
        return _node->template childStorage<Child<k>::mapped_index>();
      }
 
 
      template<std::size_t k>
      auto childStorage (index_constant<k> = {}) const
      {
        return _node->template childStorage<Child<k>::mapped_index>();
      }
 
      template<std::size_t k, class ChildType>
      void setChild (ChildType&& child, typename std::enable_if<lazy_enable<k>::value,void*>::type = 0)
      {
        _node->template setChild<Child<k>::mapped_index>(std::forward<ChildType>(child));
      }
 
 
 
    protected:
 
 
      template<bool enabled = !nodeIsConst>
      typename std::enable_if<enabled,Node&>::type
      unfiltered ()
      {
        return *_node;
      }
 
 
      const Node& unfiltered () const
      {
        return *_node;
      }
 
 
      template<bool enabled = !nodeIsConst>
      typename std::enable_if<enabled,std::shared_ptr<Node> >::type
      unfilteredStorage ()
      {
        return _node;
      }
 
 
      std::shared_ptr<const Node> unfilteredStorage () const
      {
        return _node;
      }
 
 
    public:
 
 
      FilteredCompositeNode (std::shared_ptr<Node> node)
        : _node(std::move(node))
      {}
 
      FilteredCompositeNode (Node& node)
        : _node(stackobject_to_shared_ptr(node))
      {}
 
 
    private:
      std::shared_ptr<Node> _node;
    };
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH