proxynode.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_PROXYNODE_HH
#define DUNE_TYPETREE_PROXYNODE_HH
 
#include <type_traits>
#include <dune/typetree/nodeinterface.hh>
#include <dune/typetree/nodetags.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/indices.hh>
 
namespace Dune {
  namespace TypeTree {
 
    template<typename Node>
    class ProxyNode;
 
    template<typename ProxiedNode>
    class StaticChildAccessors
    {
 
      static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
 
      template<std::size_t k>
      struct lazy_enabled
      {
        static const bool value = !proxiedNodeIsConst;
      };
 
      typedef ProxyNode<ProxiedNode> Node;
 
      template<bool enabled = !proxiedNodeIsConst>
      typename std::enable_if<enabled,Node&>::type
      node()
      {
        return static_cast<Node&>(*this);
      }
 
      const Node& node() const
      {
        return static_cast<const Node&>(*this);
      }
 
    public:
 
      template<std::size_t k>
      struct Child
        : public ProxiedNode::template Child<k>
      {};
 
 
 
      template<std::size_t k>
      typename std::enable_if<lazy_enabled<k>::value,typename Child<k>::Type&>::type
      child(Dune::index_constant<k> = {})
      {
        return node().proxiedNode().template child<k>();
      }
 
 
      template<std::size_t k>
      const typename Child<k>::Type& child(Dune::index_constant<k> = {}) const
      {
        return node().proxiedNode().template child<k>();
      }
 
 
      template<std::size_t k>
      typename std::enable_if<lazy_enabled<k>::value,typename Child<k>::Storage>::type
      childStorage()
      {
        return node().proxiedNode().template childStorage<k>();
      }
 
 
      template<std::size_t k>
      typename Child<k>::ConstStorage childStorage() const
      {
        return node().proxiedNode().template childStorage<k>();
      }
 
      template<std::size_t k>
      void setChild(typename Child<k>::type& child, typename std::enable_if<lazy_enabled<k>::value,void*>::type = 0)
      {
        node().proxiedNode().template childStorage<k>() = stackobject_to_shared_ptr(child);
      }
 
      template<std::size_t k>
      void setChild(typename Child<k>::storage_type child, typename std::enable_if<lazy_enabled<k>::value,void*>::type = 0)
      {
        node().proxiedNode().template childStorage<k>() = child;
      }
 
      const typename ProxiedNode::NodeStorage& nodeStorage() const
      {
        return node().proxiedNode().nodeStorage();
      }
 
    };
 
 
    template<typename ProxiedNode>
    class DynamicChildAccessors
      : public StaticChildAccessors<ProxiedNode>
    {
 
      typedef ProxyNode<ProxiedNode> Node;
 
      static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
 
      template<bool enabled = !proxiedNodeIsConst>
      typename std::enable_if<enabled,Node&>::type
      node()
      {
        return static_cast<Node&>(*this);
      }
 
      const Node& node() const
      {
        return static_cast<const Node&>(*this);
      }
 
    public:
 
 
 
      template<bool enabled = !proxiedNodeIsConst>
      typename std::enable_if<enabled,typename ProxiedNode::ChildType&>::type
      child (std::size_t i)
      {
        return node().proxiedNode().child(i);
      }
 
 
      const typename ProxiedNode::ChildType& child (std::size_t i) const
      {
        return node().proxiedNode().child(i);
      }
 
 
      template<bool enabled = !proxiedNodeIsConst>
      typename std::enable_if<enabled,typename ProxiedNode::ChildStorageType>::type
      childStorage(std::size_t i)
      {
        return node().proxiedNode().childStorage(i);
      }
 
 
      typename ProxiedNode::ChildConstStorageType childStorage (std::size_t i) const
      {
        return node().proxiedNode().childStorage(i);
      }
 
      template<bool enabled = !proxiedNodeIsConst>
      void setChild (std::size_t i, typename ProxiedNode::ChildType& t, typename std::enable_if<enabled,void*>::type = 0)
      {
        node().proxiedNode().childStorage(i) = stackobject_to_shared_ptr(t);
      }
 
      template<bool enabled = !proxiedNodeIsConst>
      void setChild (std::size_t i, typename ProxiedNode::ChildStorageType st, typename std::enable_if<enabled,void*>::type = 0)
      {
        node().proxiedNode().childStorage(i) = st;
      }
 
    };
 
    template<typename Node, typename NodeTag>
    struct ProxyNodeBase;
 
    template<typename Node>
    struct ProxyNodeBase<Node,LeafNodeTag>
    {
    };
 
    template<typename Node>
    struct ProxyNodeBase<Node,CompositeNodeTag>
      : public StaticChildAccessors<Node>
    {
      typedef typename Node::ChildTypes ChildTypes;
      typedef typename Node::NodeStorage NodeStorage;
    };
 
    template<typename Node>
    struct ProxyNodeBase<Node,PowerNodeTag>
      : public DynamicChildAccessors<Node>
    {
      typedef typename Node::ChildType ChildType;
      typedef typename Node::NodeStorage NodeStorage;
    };
 
 
 
    template<typename Node>
    class ProxyNode
      : public ProxyNodeBase<Node,NodeTag<Node>>
    {
 
      static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
 
      // accessor mixins need to be friends for access to proxiedNode()
      friend class StaticChildAccessors<Node>;
      friend class DynamicChildAccessors<Node>;
 
    public:
 
      typedef Node ProxiedNode;
 
      typedef Dune::TypeTree::NodeTag<Node> NodeTag;
 
      static const bool isLeaf = Node::isLeaf;
 
      static const bool isPower = Node::isPower;
 
      static const bool isComposite = Node::isComposite;
 
      static const std::size_t CHILDREN = StaticDegree<Node>::value;
 
      static constexpr std::size_t degree()
      {
        return StaticDegree<Node>::value;
      }
 
 
    protected:
 
 
      template<bool enabled = !proxiedNodeIsConst>
      typename std::enable_if<enabled,Node&>::type
      proxiedNode()
      {
        return *_node;
      }
 
      const Node& proxiedNode() const
      {
        return *_node;
      }
 
      template<bool enabled = !proxiedNodeIsConst>
      typename std::enable_if<enabled,std::shared_ptr<Node> >::type
      proxiedNodeStorage()
      {
        return _node;
      }
 
      std::shared_ptr<const Node> proxiedNodeStorage() const
      {
        return _node;
      }
 
 
 
      ProxyNode(Node& node)
        : _node(stackobject_to_shared_ptr(node))
      {}
 
      ProxyNode(std::shared_ptr<Node> node)
        : _node(node)
      {}
 
 
    private:
 
      std::shared_ptr<Node> _node;
    };
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_PROXYNODE_HH