Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : /**
       4             :  * \ingroup async
       5             :  */
       6             : #pragma once
       7             : 
       8             : namespace async
       9             : {
      10             : template<typename Node>
      11             : class Queue
      12             : {
      13             : public:
      14             :     Queue();
      15             : 
      16             :     void enqueue(Node& node);
      17             :     Node* dequeue();
      18             : 
      19             :     void clear();
      20             :     void remove(Node& node);
      21             : 
      22             : private:
      23             :     Node* _first;
      24             :     Node* _last;
      25             : };
      26             : 
      27             : /**
      28             :  * Inline implementations.
      29             :  */
      30             : template<typename Node>
      31         183 : Queue<Node>::Queue() : _first(nullptr), _last(nullptr)
      32             : {}
      33             : 
      34             : template<typename Node>
      35          21 : void Queue<Node>::enqueue(Node& node)
      36             : {
      37          19 :     node.enqueue();
      38          14 :     if (_last != nullptr)
      39             :     {
      40           8 :         _last->setNext(&node);
      41             :     }
      42             :     else
      43             :     {
      44          11 :         _first = &node;
      45             :     }
      46          17 :     _last = &node;
      47           8 : }
      48             : 
      49             : template<typename Node>
      50          24 : Node* Queue<Node>::dequeue()
      51             : {
      52          25 :     if (_first != nullptr)
      53             :     {
      54          14 :         Node* const node = _first;
      55          13 :         if (_last == node)
      56             :         {
      57           8 :             _last = nullptr;
      58             :         }
      59          14 :         _first = node->dequeue();
      60          10 :         return node;
      61             :     }
      62             :     return nullptr;
      63             : }
      64             : 
      65             : template<typename Node>
      66           1 : void Queue<Node>::clear()
      67             : {
      68           3 :     while (_first != nullptr)
      69             :     {
      70           2 :         _first = _first->dequeue();
      71             :     }
      72           1 :     _last = nullptr;
      73             : }
      74             : 
      75             : template<typename Node>
      76           4 : void Queue<Node>::remove(Node& node)
      77             : {
      78           4 :     Node* prevNode    = nullptr;
      79           4 :     Node* currentNode = _first;
      80           6 :     while (currentNode != nullptr)
      81             :     {
      82           5 :         if (currentNode == &node)
      83             :         {
      84           3 :             if (prevNode != nullptr)
      85             :             {
      86           2 :                 prevNode->setNext(node.dequeue());
      87             :             }
      88             :             else
      89             :             {
      90           1 :                 _first = node.dequeue();
      91             :             }
      92           3 :             if (_last == &node)
      93             :             {
      94           1 :                 _last = prevNode;
      95             :             }
      96             :             break;
      97             :         }
      98           2 :         prevNode    = currentNode;
      99           2 :         currentNode = currentNode->getNext();
     100             :     }
     101           4 : }
     102             : 
     103             : } // namespace async