"Fossies" - the Fresh Open Source Software Archive

Member "dune-typetree-2.8.0/dune/typetree/proxynode.hh" (31 Aug 2021, 9832 Bytes) of package /linux/misc/dune/dune-typetree-2.8.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "proxynode.hh" see the Fossies "Dox" file reference documentation.

    1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    2 // vi: set et ts=4 sw=2 sts=2:
    3 
    4 #ifndef DUNE_TYPETREE_PROXYNODE_HH
    5 #define DUNE_TYPETREE_PROXYNODE_HH
    6 
    7 #include <type_traits>
    8 #include <dune/typetree/nodeinterface.hh>
    9 #include <dune/typetree/nodetags.hh>
   10 #include <dune/common/shared_ptr.hh>
   11 #include <dune/common/indices.hh>
   12 #include <dune/common/std/type_traits.hh>
   13 
   14 namespace Dune {
   15   namespace TypeTree {
   16 
   17     /** \addtogroup Nodes
   18      *  \ingroup TypeTree
   19      *  \{
   20      */
   21 
   22     template<typename Node>
   23     class ProxyNode;
   24 
   25     //! Mixin class providing methods for child access with compile-time parameter.
   26     template<typename ProxiedNode>
   27     class StaticChildAccessors
   28     {
   29 
   30       static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
   31 
   32       template<std::size_t k>
   33       struct lazy_enabled
   34       {
   35         static const bool value = !proxiedNodeIsConst;
   36       };
   37 
   38       typedef ProxyNode<ProxiedNode> Node;
   39 
   40       template<bool enabled = !proxiedNodeIsConst>
   41       typename std::enable_if<enabled,Node&>::type
   42       node ()
   43       {
   44         return static_cast<Node&>(*this);
   45       }
   46 
   47       const Node& node () const
   48       {
   49         return static_cast<const Node&>(*this);
   50       }
   51 
   52     public:
   53 
   54       //! Access to the type and storage type of the i-th child.
   55       template<std::size_t k>
   56       struct Child
   57         : public ProxiedNode::template Child<k>
   58       {};
   59 
   60       //! @name Child Access
   61       //! @{
   62 
   63       //! Returns the i-th child.
   64       /**
   65        * \returns a reference to the i-th child.
   66        */
   67       template<std::size_t k,
   68         typename std::enable_if<lazy_enabled<k>::value, int>::type = 0>
   69       auto& child (index_constant<k> = {})
   70       {
   71         return node().proxiedNode().template child<k>();
   72       }
   73 
   74       //! Returns the i-th child (const version).
   75       /**
   76        * \returns a const reference to the i-th child.
   77        */
   78       template<std::size_t k>
   79       const auto& child (index_constant<k> = {}) const
   80       {
   81         return node().proxiedNode().template child<k>();
   82       }
   83 
   84       //! Returns the storage of the i-th child.
   85       /**
   86        * \returns a copy of the object storing the i-th child.
   87        */
   88       template<std::size_t k,
   89         typename std::enable_if<lazy_enabled<k>::value, int>::type = 0>
   90       auto childStorage (index_constant<k> = {})
   91       {
   92         return node().proxiedNode().template childStorage<k>();
   93       }
   94 
   95       //! Returns the storage of the i-th child (const version).
   96       /**
   97        * This method is only important if the child is stored as
   98        * some kind of pointer, as this allows the pointee type to
   99        * become const.
  100        * \returns a copy of the object storing the i-th child.
  101        */
  102       template<std::size_t k>
  103       auto childStorage (index_constant<k> = {}) const
  104       {
  105         return node().proxiedNode().template childStorage<k>();
  106       }
  107 
  108       //! Sets the i-th child to the passed-in value.
  109       template<std::size_t k, class ProxyChild>
  110       void setChild (ProxyChild&& child, typename std::enable_if<lazy_enabled<k>::value,void*>::type = 0)
  111       {
  112         node().proxiedNode().template setChild<k>(std::forward<ProxyChild>(child));
  113       }
  114 
  115       const typename ProxiedNode::NodeStorage& nodeStorage () const
  116       {
  117         return node().proxiedNode().nodeStorage();
  118       }
  119 
  120     };
  121 
  122     //! Mixin class providing methods for child access with run-time parameter.
  123     /**
  124      * This class also provides the compile-time parameter based methods, as
  125      * multiple inheritance from both DynamicChildAccessors and StaticChildAccessors
  126      * creates ambigous method lookups.
  127      */
  128     template<typename ProxiedNode>
  129     class DynamicChildAccessors
  130       : public StaticChildAccessors<ProxiedNode>
  131     {
  132 
  133       typedef ProxyNode<ProxiedNode> Node;
  134 
  135       static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
  136 
  137       template<bool enabled = !proxiedNodeIsConst>
  138       typename std::enable_if<enabled,Node&>::type
  139       node ()
  140       {
  141         return static_cast<Node&>(*this);
  142       }
  143 
  144       const Node& node () const
  145       {
  146         return static_cast<const Node&>(*this);
  147       }
  148 
  149     public:
  150 
  151       //! @name Child Access (Dynamic methods)
  152       //! @{
  153 
  154       //! Returns the i-th child.
  155       /**
  156        * \returns a reference to the i-th child.
  157        */
  158       template<bool enabled = !proxiedNodeIsConst,
  159         typename std::enable_if<enabled, int>::type = 0>
  160       auto& child (std::size_t i)
  161       {
  162         return node().proxiedNode().child(i);
  163       }
  164 
  165       //! Returns the i-th child (const version).
  166       /**
  167        * \returns a const reference to the i-th child.
  168        */
  169       const auto& child (std::size_t i) const
  170       {
  171         return node().proxiedNode().child(i);
  172       }
  173 
  174       //! Returns the storage of the i-th child.
  175       /**
  176        * \returns a copy of the object storing the i-th child.
  177        */
  178       template<bool enabled = !proxiedNodeIsConst,
  179         typename std::enable_if<enabled, int>::type = 0>
  180       auto childStorage (std::size_t i)
  181       {
  182         return node().proxiedNode().childStorage(i);
  183       }
  184 
  185       //! Returns the storage of the i-th child (const version).
  186       /**
  187        * This method is only important if the child is stored as
  188        * some kind of pointer, as this allows the pointee type to
  189        * become const.
  190        * \returns a copy of the object storing the i-th child.
  191        */
  192       auto childStorage (std::size_t i) const
  193       {
  194         return node().proxiedNode().childStorage(i);
  195       }
  196 
  197       //! Sets the i-th child to the passed-in value.
  198       template<class ProxyChild, bool enabled = !proxiedNodeIsConst>
  199       void setChild (std::size_t i, ProxyChild&& child, typename std::enable_if<enabled,void*>::type = 0)
  200       {
  201         node().proxiedNode().setChild(i, std::forward<ProxyChild>(child));
  202       }
  203 
  204     };
  205 
  206     //! Tag-based dispatch to appropriate base class that provides necessary functionality.
  207     template<typename Node, typename NodeTag>
  208     struct ProxyNodeBase;
  209 
  210     //! ProxyNode base class for LeafNode.
  211     template<typename Node>
  212     struct ProxyNodeBase<Node,LeafNodeTag>
  213     {
  214     };
  215 
  216     //! ProxyNode base class for CompositeNode.
  217     template<typename Node>
  218     struct ProxyNodeBase<Node,CompositeNodeTag>
  219       : public StaticChildAccessors<Node>
  220     {
  221       typedef typename Node::ChildTypes ChildTypes;
  222       typedef typename Node::NodeStorage NodeStorage;
  223     };
  224 
  225     //! ProxyNode base class for PowerNode.
  226     template<typename Node>
  227     struct ProxyNodeBase<Node,PowerNodeTag>
  228       : public DynamicChildAccessors<Node>
  229     {
  230       typedef typename Node::ChildType ChildType;
  231       typedef typename Node::NodeStorage NodeStorage;
  232     };
  233 
  234 
  235     //! Base class for nodes acting as a proxy for an existing node.
  236     /**
  237      * ProxyNode is a utility class for implementing proxy classes
  238      * that need to provide the TypeTree node functionality of the
  239      * proxied class. It exactly mirrors the TypeTree node characteristics
  240      * of the proxied node.
  241      */
  242     template<typename Node>
  243     class ProxyNode
  244       : public ProxyNodeBase<Node,NodeTag<Node>>
  245     {
  246       static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
  247 
  248       template <class N>
  249       using HasStaticDegree = index_constant<N::degree()>;
  250 
  251       template <class N>
  252       static constexpr bool hasStaticDegree = Std::is_detected<HasStaticDegree, N>::value;
  253 
  254       // accessor mixins need to be friends for access to proxiedNode()
  255       friend class StaticChildAccessors<Node>;
  256       friend class DynamicChildAccessors<Node>;
  257 
  258     public:
  259 
  260       typedef Node ProxiedNode;
  261 
  262       typedef Dune::TypeTree::NodeTag<Node> NodeTag;
  263 
  264       //! Mark this class as non leaf in the \ref TypeTree.
  265       static const bool isLeaf = Node::isLeaf;
  266 
  267       //! Mark this class as a non power in the \ref TypeTree.
  268       static const bool isPower = Node::isPower;
  269 
  270       //! Mark this class as a composite in the \ref TypeTree.
  271       static const bool isComposite = Node::isComposite;
  272 
  273       //! The number of children.
  274       static const std::size_t CHILDREN = StaticDegree<Node>::value;
  275 
  276       template <class N = Node,
  277         std::enable_if_t<hasStaticDegree<N>, int> = 0>
  278       static constexpr auto degree ()
  279       {
  280         return N::degree();
  281       }
  282 
  283       template <class N = Node,
  284         std::enable_if_t<not hasStaticDegree<N>, int> = 0>
  285       auto degree () const
  286       {
  287         return proxiedNode().degree();
  288       }
  289 
  290 
  291     protected:
  292 
  293       //! @name Access to the proxied node
  294       //! @{
  295 
  296       //! Returns the proxied node.
  297       template<bool enabled = !proxiedNodeIsConst>
  298       typename std::enable_if<enabled,Node&>::type
  299       proxiedNode ()
  300       {
  301         return *_node;
  302       }
  303 
  304       //! Returns the proxied node (const version).
  305       const Node& proxiedNode () const
  306       {
  307         return *_node;
  308       }
  309 
  310       //! Returns the storage of the proxied node.
  311       template<bool enabled = !proxiedNodeIsConst>
  312       typename std::enable_if<enabled,std::shared_ptr<Node> >::type
  313       proxiedNodeStorage ()
  314       {
  315         return _node;
  316       }
  317 
  318       //! Returns the storage of the proxied node (const version).
  319       std::shared_ptr<const Node> proxiedNodeStorage () const
  320       {
  321         return _node;
  322       }
  323 
  324       //! @}
  325 
  326       //! @name Constructors
  327       //! @{
  328 
  329       ProxyNode (Node& node)
  330         : _node(stackobject_to_shared_ptr(node))
  331       {}
  332 
  333       ProxyNode (std::shared_ptr<Node> node)
  334         : _node(std::move(node))
  335       {}
  336 
  337       //! @}
  338 
  339     private:
  340 
  341       std::shared_ptr<Node> _node;
  342     };
  343 
  344     //! \} group Nodes
  345 
  346   } // namespace TypeTree
  347 } //namespace Dune
  348 
  349 #endif // DUNE_TYPETREE_PROXYNODE_HH