LCOV - code coverage report
Current view: top level - Utils - WorkQueueLoopThread.h (source / functions) Coverage Total Hit
Test: OdbDesign Test Coverage Lines: 19.0 % 42 8
Test Date: 2026-11-21 03:51:50 Functions: 28.6 % 7 2
Legend: Lines: hit not hit

            Line data    Source code
       1              : //
       2              : // Created by nam20485 on 5/30/22.
       3              : //
       4              : 
       5              : #pragma once
       6              : 
       7              : #include "ThreadSafeQueue.h"
       8              : #include <thread>
       9              : #include <memory>
      10              : #include <chrono>
      11              : 
      12              : 
      13              : namespace Utils
      14              : {
      15              :     template<typename TWorkItem>
      16              :     class WorkQueueLoopThread
      17              :     {
      18              :     public:
      19              :         typedef std::function<bool(TWorkItem&)> processWorkItemFunc;
      20              : 
      21              :         WorkQueueLoopThread();
      22              :         explicit WorkQueueLoopThread(processWorkItemFunc processWorkItemProc/*, bool enableInternalLogging*/);
      23              : 
      24              :         void addWorkItem(TWorkItem&& workItem);
      25              :         //void addWorkItem(TWorkItem& workItem);
      26              :         void startProcessing();
      27              :         void stopProcessing();
      28              : 
      29              :     protected:       
      30              :         void processWorkItemsLoop();
      31              :         virtual bool processWorkItem(TWorkItem& workItem);
      32              : 
      33              :     private:
      34              :         ThreadSafeQueue<TWorkItem> _workItemQueue;
      35              :         std::unique_ptr<std::thread> _processWorkItemsLoopThread;
      36              :         std::atomic_bool _stopProcessingWorkItemsFlag;
      37              :         processWorkItemFunc _processWorkItemProc;
      38              : 
      39              :         const bool _StopProcessingOnWorkItemFail{ true };
      40              :         bool _enableInternalLogging{ false };
      41              : 
      42              :     };
      43              :     
      44              :     template<typename TWorkItem>
      45            0 :     /*virtual*/ bool WorkQueueLoopThread<TWorkItem>::processWorkItem(TWorkItem& workItem)
      46              :     {
      47            0 :         if (_processWorkItemProc == nullptr) return false;       
      48            0 :         return _processWorkItemProc(workItem);       
      49              :     }
      50              : 
      51              : 
      52              :     template<typename TWorkItem>
      53              :     inline WorkQueueLoopThread<TWorkItem>::WorkQueueLoopThread()
      54              :         : WorkQueueLoopThread(nullptr)
      55              :     {
      56              :     }
      57              : 
      58              :     template<typename TWorkItem>
      59          125 :     WorkQueueLoopThread<TWorkItem>::WorkQueueLoopThread(WorkQueueLoopThread::processWorkItemFunc processWorkItemProc/*, bool enableInternalLogging*/)
      60          125 :         : _stopProcessingWorkItemsFlag(false)
      61          250 :         , _processWorkItemProc(processWorkItemProc)
      62              :         //, _enableInternalLogging(enableInternalLogging)
      63              :     {
      64          125 :         if (_enableInternalLogging)
      65              :         {
      66            0 :             _workItemQueue.registerInternalLogHandler([&](const std::string& m)
      67              :                 {
      68            0 :                     std::cout << m << std::endl;
      69              :                 });
      70              :         }
      71          125 :     }
      72              : 
      73              :     template<typename TWorkItem>
      74       429440 :     void WorkQueueLoopThread<TWorkItem>::addWorkItem(TWorkItem&& workItem)
      75              :     {
      76       429440 :         _workItemQueue.push(std::move(workItem));
      77       429440 :     }
      78              : 
      79              :   //  template<typename TWorkItem>
      80              :   //  inline void WorkQueueLoopThread<TWorkItem>::addWorkItem(TWorkItem& workItem)
      81              :   //  {
      82              :                 //_workItemQueue.push(workItem);
      83              :   //  }
      84              : 
      85              :     template<typename TWorkItem>
      86            0 :     void WorkQueueLoopThread<TWorkItem>::processWorkItemsLoop()
      87              :     {
      88            0 :         while (!_stopProcessingWorkItemsFlag.load())
      89              :         {
      90            0 :             auto wait_result = _workItemQueue.wait(/*std::chrono::milliseconds(1)*/);
      91            0 :             switch (wait_result)
      92              :             {
      93            0 :                 case ThreadSafeQueue<TWorkItem>::wait_result::timed_out:
      94            0 :                     break;
      95            0 :                 case ThreadSafeQueue<TWorkItem>::wait_result::interrupted:
      96            0 :                                         break;
      97            0 :                 case ThreadSafeQueue<TWorkItem>::wait_result::notified:
      98            0 :                                         break;
      99            0 :                                 default:
     100            0 :                                         break;
     101              :             }                  
     102              : 
     103            0 :             while (!_workItemQueue.empty())
     104              :             {
     105            0 :                 auto workItem = _workItemQueue.front(false);
     106            0 :                 if (!processWorkItem(workItem))
     107              :                 {
     108            0 :                     if (_StopProcessingOnWorkItemFail)
     109              :                     {
     110            0 :                         _stopProcessingWorkItemsFlag.store(true);
     111            0 :                         break;
     112              :                     }
     113              :                 }
     114            0 :                 _workItemQueue.pop();
     115              :             }
     116              :         }
     117            0 :     }
     118              : 
     119              :     template<typename TWorkItem>
     120            0 :     void WorkQueueLoopThread<TWorkItem>::startProcessing()
     121              :     {
     122            0 :         _stopProcessingWorkItemsFlag.store(false);
     123              :         //    _processWorkItemsLoopThread = std::make_unique<std::thread>(std::thread([&]
     124              :         //                                                                            {
     125              :         //                                                                                processWorkItemsLoop();
     126              :         //                                                                            }));
     127              : 
     128            0 :         _processWorkItemsLoopThread = std::make_unique<std::thread>(std::thread(&WorkQueueLoopThread::processWorkItemsLoop, this));
     129            0 :     }
     130              : 
     131              :     template<typename TWorkItem>
     132            0 :     void WorkQueueLoopThread<TWorkItem>::stopProcessing()
     133              :     {
     134            0 :         _stopProcessingWorkItemsFlag.store(true);
     135            0 :         _workItemQueue.interrupt();
     136            0 :         _processWorkItemsLoopThread->join();
     137            0 :     }
     138              : }
        

Generated by: LCOV version 2.0-1