Line data    Source code

       1             : #ifdef __PLUMED_HAS_ASMJIT
       2             : // This file is part of AsmJit project <https://asmjit.com>
       3             : //
       4             : // See asmjit.h or LICENSE.md for license and copyright information
       5             : // SPDX-License-Identifier: Zlib
       6             : 
       7             : #ifndef ASMJIT_CORE_ZONELIST_H_INCLUDED
       8             : #define ASMJIT_CORE_ZONELIST_H_INCLUDED
       9             : 
      10             : #include "support.h"
      11             : 
      12             : ASMJIT_BEGIN_NAMESPACE
      13             : 
      14             : //! \addtogroup asmjit_zone
      15             : //! \{
      16             : 
      17             : //! Node used by \ref ZoneList template.
      18             : template<typename NodeT>
      19             : class ZoneListNode {
      20             : public:
      21             :   ASMJIT_NONCOPYABLE(ZoneListNode)
      22             : 
      23             :   //! \name Constants
      24             :   //! \{
      25             : 
      26             :   enum : size_t {
      27             :     kNodeIndexPrev = 0,
      28             :     kNodeIndexNext = 1
      29             :   };
      30             : 
      31             :   //! \}
      32             : 
      33             :   //! \name Members
      34             :   //! \{
      35             : 
      36             :   NodeT* _listNodes[2];
      37             : 
      38             :   //! \}
      39             : 
      40             :   //! \name Construction & Destruction
      41             :   //! \{
      42             : 
      43       27392 :   inline ZoneListNode() noexcept
      44       27392 :     : _listNodes { nullptr, nullptr } {}
      45             : 
      46             :   inline ZoneListNode(ZoneListNode&& other) noexcept
      47             :     : _listNodes { other._listNodes[0], other._listNodes[1] } {}
      48             : 
      49             :   //! \}
      50             : 
      51             :   //! \name Accessors
      52             :   //! \{
      53             : 
      54           0 :   inline bool hasPrev() const noexcept { return _listNodes[kNodeIndexPrev] != nullptr; }
      55         100 :   inline bool hasNext() const noexcept { return _listNodes[kNodeIndexNext] != nullptr; }
      56             : 
      57           0 :   inline NodeT* prev() const noexcept { return _listNodes[kNodeIndexPrev]; }
      58       27392 :   inline NodeT* next() const noexcept { return _listNodes[kNodeIndexNext]; }
      59             : 
      60             :   //! \}
      61             : };
      62             : 
      63             : //! Zone allocated list container that uses nodes of `NodeT` type.
      64             : template <typename NodeT>
      65             : class ZoneList {
      66             : public:
      67             :   ASMJIT_NONCOPYABLE(ZoneList)
      68             : 
      69             :   //! \name Constants
      70             :   //! \{
      71             : 
      72             :   enum : size_t {
      73             :     kNodeIndexFirst = 0,
      74             :     kNodeIndexLast = 1
      75             :   };
      76             : 
      77             :   //! \}
      78             : 
      79             :   //! \name Members
      80             :   //! \{
      81             : 
      82             :   NodeT* _nodes[2];
      83             : 
      84             :   //! \}
      85             : 
      86             :   //! \name Construction & Destruction
      87             :   //! \{
      88             : 
      89       27422 :   inline ZoneList() noexcept
      90       27422 :     : _nodes { nullptr, nullptr } {}
      91             : 
      92             :   inline ZoneList(ZoneList&& other) noexcept
      93             :     : _nodes { other._nodes[0], other._nodes[1] } {}
      94             : 
      95             :   inline void reset() noexcept {
      96       27422 :     _nodes[0] = nullptr;
      97       27422 :     _nodes[1] = nullptr;
      98             :   }
      99             : 
     100             :   //! \}
     101             : 
     102             :   //! \name Accessors
     103             :   //! \{
     104             : 
     105             :   inline bool empty() const noexcept { return _nodes[0] == nullptr; }
     106       55014 :   inline NodeT* first() const noexcept { return _nodes[kNodeIndexFirst]; }
     107       27392 :   inline NodeT* last() const noexcept { return _nodes[kNodeIndexLast]; }
     108             : 
     109             :   //! \}
     110             : 
     111             :   //! \name Utilities
     112             :   //! \{
     113             : 
     114             :   inline void swap(ZoneList& other) noexcept {
     115             :     std::swap(_nodes[0], other._nodes[0]);
     116             :     std::swap(_nodes[1], other._nodes[1]);
     117             :   }
     118             : 
     119             :   // Can be used to both append and prepend.
     120             :   inline void _addNode(NodeT* node, size_t dir) noexcept {
     121       27392 :     NodeT* prev = _nodes[dir];
     122             : 
     123       27392 :     node->_listNodes[!dir] = prev;
     124       27392 :     _nodes[dir] = node;
     125       27392 :     if (prev)
     126           0 :       prev->_listNodes[dir] = node;
     127             :     else
     128       27392 :       _nodes[!dir] = node;
     129             :   }
     130             : 
     131             :   // Can be used to both append and prepend.
     132             :   inline void _insertNode(NodeT* ref, NodeT* node, size_t dir) noexcept {
     133             :     ASMJIT_ASSERT(ref != nullptr);
     134             : 
     135             :     NodeT* prev = ref;
     136             :     NodeT* next = ref->_listNodes[dir];
     137             : 
     138             :     prev->_listNodes[dir] = node;
     139             :     if (next)
     140             :       next->_listNodes[!dir] = node;
     141             :     else
     142             :       _nodes[dir] = node;
     143             : 
     144             :     node->_listNodes[!dir] = prev;
     145             :     node->_listNodes[ dir] = next;
     146             :   }
     147             : 
     148             :   inline void append(NodeT* node) noexcept { _addNode(node, kNodeIndexLast); }
     149             :   inline void prepend(NodeT* node) noexcept { _addNode(node, kNodeIndexFirst); }
     150             : 
     151             :   inline void insertAfter(NodeT* ref, NodeT* node) noexcept { _insertNode(ref, node, NodeT::kNodeIndexNext); }
     152             :   inline void insertBefore(NodeT* ref, NodeT* node) noexcept { _insertNode(ref, node, NodeT::kNodeIndexPrev); }
     153             : 
     154           0 :   inline NodeT* unlink(NodeT* node) noexcept {
     155             :     NodeT* prev = node->prev();
     156             :     NodeT* next = node->next();
     157             : 
     158           0 :     if (prev) { prev->_listNodes[1] = next; node->_listNodes[0] = nullptr; } else { _nodes[0] = next; }
     159           0 :     if (next) { next->_listNodes[0] = prev; node->_listNodes[1] = nullptr; } else { _nodes[1] = prev; }
     160             : 
     161           0 :     node->_listNodes[0] = nullptr;
     162           0 :     node->_listNodes[1] = nullptr;
     163             : 
     164           0 :     return node;
     165             :   }
     166             : 
     167             :   inline NodeT* popFirst() noexcept {
     168             :     NodeT* node = _nodes[0];
     169             :     ASMJIT_ASSERT(node != nullptr);
     170             : 
     171             :     NodeT* next = node->next();
     172             :     _nodes[0] = next;
     173             : 
     174             :     if (next) {
     175             :       next->_listNodes[0] = nullptr;
     176             :       node->_listNodes[1] = nullptr;
     177             :     }
     178             :     else {
     179             :       _nodes[1] = nullptr;
     180             :     }
     181             : 
     182             :     return node;
     183             :   }
     184             : 
     185             :   inline NodeT* pop() noexcept {
     186             :     NodeT* node = _nodes[1];
     187             :     ASMJIT_ASSERT(node != nullptr);
     188             : 
     189             :     NodeT* prev = node->prev();
     190             :     _nodes[1] = prev;
     191             : 
     192             :     if (prev) {
     193             :       prev->_listNodes[1] = nullptr;
     194             :       node->_listNodes[0] = nullptr;
     195             :     }
     196             :     else {
     197             :       _nodes[0] = nullptr;
     198             :     }
     199             : 
     200             :     return node;
     201             :   }
     202             : 
     203             :   //! \}
     204             : };
     205             : 
     206             : //! \}
     207             : 
     208             : ASMJIT_END_NAMESPACE
     209             : 
     210             : #endif // ASMJIT_CORE_ZONELIST_H_INCLUDED
     211             : 
     212             : #endif // __PLUMED_HAS_ASMJIT