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          183 : {}
      33              : 
      34              : template<typename Node>
      35           21 : void Queue<Node>::enqueue(Node& node)
      36              : {
      37           21 :     node.enqueue();
      38           21 :     if (_last != nullptr)
      39              :     {
      40            9 :         _last->setNext(&node);
      41              :     }
      42              :     else
      43              :     {
      44           12 :         _first = &node;
      45              :     }
      46           21 :     _last = &node;
      47           21 : }
      48              : 
      49              : template<typename Node>
      50           26 : Node* Queue<Node>::dequeue()
      51              : {
      52           26 :     if (_first != nullptr)
      53              :     {
      54           14 :         Node* const node = _first;
      55           14 :         if (_last == node)
      56              :         {
      57            9 :             _last = nullptr;
      58              :         }
      59           14 :         _first = node->dequeue();
      60           14 :         return node;
      61              :     }
      62           12 :     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            1 : }
      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            3 :             break;
      97              :         }
      98            2 :         prevNode    = currentNode;
      99            2 :         currentNode = currentNode->getNext();
     100              :     }
     101            4 : }
     102              : 
     103              : } // namespace async