powernode.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_POWERNODE_HH
#define DUNE_TYPETREE_POWERNODE_HH
 
#include <cassert>
#include <array>
#include <memory>
#include <type_traits>
 
#include <dune/common/typetraits.hh>
#include <dune/common/std/type_traits.hh>
 
#include <dune/typetree/nodetags.hh>
#include <dune/typetree/utility.hh>
#include <dune/typetree/childextraction.hh>
#include <dune/typetree/typetraits.hh>
 
namespace Dune {
  namespace TypeTree {
 
#ifndef DOXYGEN
 
    template<typename PowerNode, typename T, std::size_t k>
    struct AssertPowerNodeChildCount
      : public std::enable_if<std::is_same<
                           typename PowerNode::ChildType,
                           T>::value &&
    PowerNode::CHILDREN == k,
                         T>
    {};
 
#endif
 
    template<typename T, std::size_t k>
    class PowerNode
    {
 
    public:
 
      static const bool isLeaf = false;
 
      static const bool isPower = true;
 
      static const bool isComposite = false;
 
      static const std::size_t CHILDREN = k;
 
      static constexpr auto degree ()
      {
        return std::integral_constant<std::size_t,k>{};
      }
 
      typedef PowerNodeTag NodeTag;
 
      typedef T ChildType;
 
      typedef std::array<std::shared_ptr<T>,k> NodeStorage;
 
 
      template<std::size_t i>
      struct Child
      {
 
        static_assert((i < CHILDREN), "child index out of range");
 
        typedef T Type;
 
        typedef T type;
      };
 
 
 
      template<std::size_t i>
      T& child (index_constant<i> = {})
      {
        static_assert((i < CHILDREN), "child index out of range");
        return *_children[i];
      }
 
 
      template<std::size_t i>
      const T& child (index_constant<i> = {}) const
      {
        static_assert((i < CHILDREN), "child index out of range");
        return *_children[i];
      }
 
 
      template<std::size_t i>
      std::shared_ptr<T> childStorage (index_constant<i> = {})
      {
        static_assert((i < CHILDREN), "child index out of range");
        return _children[i];
      }
 
 
      template<std::size_t i>
      std::shared_ptr<const T> childStorage (index_constant<i> = {}) const
      {
        static_assert((i < CHILDREN), "child index out of range");
        return _children[i];
      }
 
      template<std::size_t i>
      void setChild (T& t, index_constant<i> = {})
      {
        static_assert((i < CHILDREN), "child index out of range");
        _children[i] = stackobject_to_shared_ptr(t);
      }
 
      template<std::size_t i>
      void setChild (T&& t, index_constant<i> = {})
      {
        static_assert((i < CHILDREN), "child index out of range");
        _children[i] = convert_arg(std::move(t));
      }
 
      template<std::size_t i>
      void setChild (std::shared_ptr<T> st, index_constant<i> = {})
      {
        static_assert((i < CHILDREN), "child index out of range");
        _children[i] = std::move(st);
      }
 
 
 
 
 
      T& child (std::size_t i)
      {
        assert(i < CHILDREN && "child index out of range");
        return *_children[i];
      }
 
 
      const T& child (std::size_t i) const
      {
        assert(i < CHILDREN && "child index out of range");
        return *_children[i];
      }
 
 
      std::shared_ptr<T> childStorage (std::size_t i)
      {
        assert(i < CHILDREN && "child index out of range");
        return _children[i];
      }
 
 
      std::shared_ptr<const T> childStorage (std::size_t i) const
      {
        assert(i < CHILDREN && "child index out of range");
        return _children[i];
      }
 
      void setChild (std::size_t i, T& t)
      {
        assert(i < CHILDREN && "child index out of range");
        _children[i] = stackobject_to_shared_ptr(t);
      }
 
      void setChild (std::size_t i, T&& t)
      {
        assert(i < CHILDREN && "child index out of range");
        _children[i] = convert_arg(std::move(t));
      }
 
      void setChild (std::size_t i, std::shared_ptr<T> st)
      {
        assert(i < CHILDREN && "child index out of range");
        _children[i] = std::move(st);
      }
 
      const NodeStorage& nodeStorage () const
      {
        return _children;
      }
 
 
 
      // The following two methods require a little bit of SFINAE trickery to work correctly:
      // We have to make sure that they don't shadow the methods for direct child access because
      // those get called by the generic child() machinery. If that machinery picks up the methods
      // defined below, we have an infinite recursion.
      // So the methods make sure that either
      //
      // * there are more than one argument. In that case, we got multiple indices and can forward
      //   to the general machine.
      //
      // * the first argument is not a valid flat index, i.e. either a std::size_t or an index_constant.
      //   The argument thus has to be some kind of TreePath instance that we can also pass to the
      //   generic machine.
      //
      // The above SFINAE logic works, but there is still a problem with the return type deduction.
      // We have to do a lazy lookup of the return type after SFINAE has succeeded, otherwise the return
      // type deduction will trigger the infinite recursion.
 
 
#ifdef DOXYGEN
      template<typename... Indices>
      ImplementationDefined& child (Indices... indices)
#else
      template<typename I0, typename... I,
        std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
      decltype(auto) child (I0 i0, I... i)
#endif
      {
        static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
          "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
          );
        return Dune::TypeTree::child(*this,i0,i...);
      }
 
 
#ifdef DOXYGEN
      template<typename... Indices>
      const ImplementationDefined& child (Indices... indices)
#else
      template<typename I0, typename... I,
        std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
      decltype(auto) child (I0 i0, I... i) const
#endif
      {
        static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
          "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
          );
        return Dune::TypeTree::child(*this,i0,i...);
      }
 
 
 
    protected:
 
 
      PowerNode ()
      {}
 
      explicit PowerNode (const NodeStorage& children)
        : _children(children)
      {}
 
      explicit PowerNode (T& t, bool distinct_objects = true)
      {
        if (distinct_objects)
          {
            for (typename NodeStorage::iterator it = _children.begin(); it != _children.end(); ++it)
              *it = std::make_shared<T>(t);
          }
        else
          {
            std::shared_ptr<T> sp = stackobject_to_shared_ptr(t);
            std::fill(_children.begin(),_children.end(),sp);
          }
      }
 
#ifdef DOXYGEN
 
      PowerNode(T& t1, T& t2, ...)
      {}
 
#else
 
      template<typename... Children,
        std::enable_if_t<
          std::conjunction<std::is_same<ChildType, std::decay_t<Children>>...>::value
          ,int> = 0>
      PowerNode (Children&&... children)
      {
        static_assert(CHILDREN == sizeof...(Children), "PowerNode constructor is called with incorrect number of children");
        _children = NodeStorage{convert_arg(std::forward<Children>(children))...};
      }
 
      template<typename... Children,
        std::enable_if_t<
          std::conjunction<std::is_same<ChildType, Children>...>::value
          ,int> = 0>
      PowerNode (std::shared_ptr<Children>... children)
      {
        static_assert(CHILDREN == sizeof...(Children), "PowerNode constructor is called with incorrect number of children");
        _children = NodeStorage{children...};
      }
 
#endif // DOXYGEN
 
 
    private:
      NodeStorage _children;
    };
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_POWERNODE_HH