Line data    Source code

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