Line data    Source code

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