Line data    Source code

       1             : namespace HLR
       2             : {
       3             : namespace Kinematics
       4             : {
       5             : template<class T>
       6        5002 : void ConcurrentQueue<T>::push(const T& element)
       7             : {
       8        5002 :     this->queue_mutex.lock();
       9        5002 :     if (this->handler)
      10             :     {
      11           2 :         auto handler_copy = this->handler;
      12           1 :         this->handler = nullptr;
      13           1 :         this->queue_mutex.unlock();
      14           1 :         handler_copy(element);
      15             :     }
      16             :     else
      17             :     {
      18        5001 :         this->queue.push(element);
      19        5001 :         this->notifier.notify_one();
      20        5001 :         this->queue_mutex.unlock();
      21             :     }
      22        5002 : }
      23             : 
      24             : template<class T>
      25        5002 : void ConcurrentQueue<T>::push(T&& element)
      26             : {
      27        5002 :     this->queue_mutex.lock();
      28        5002 :     if (this->handler)
      29             :     {
      30           2 :         auto handler_copy = this->handler;
      31           1 :         this->handler = nullptr;
      32           1 :         this->queue_mutex.unlock();
      33           1 :         handler_copy(element);
      34             :     }
      35             :     else
      36             :     {
      37        5001 :         this->queue.push(std::move(element));
      38        5001 :         this->notifier.notify_one();
      39        5001 :         this->queue_mutex.unlock();
      40             :     }
      41        5002 : }
      42             : 
      43             : template<class T>
      44       10000 : T ConcurrentQueue<T>::pop()
      45             : {
      46       20000 :     std::unique_lock<std::mutex> l(this->queue_mutex);
      47       10006 :     while (this->queue.empty())
      48             :     {
      49           3 :         notifier.wait(l);
      50             :     }
      51             : 
      52       10000 :     T element = this->queue.front();
      53       10000 :     this->queue.pop();
      54       20000 :     return element;
      55             : }
      56             : 
      57             : template<class T>
      58           4 : void ConcurrentQueue<T>::async_pop(const std::function<void(const T&)>& handler)
      59             : {
      60           4 :     this->queue_mutex.lock();
      61           4 :     if (!this->queue.empty())
      62             :     {
      63           4 :         T element = this->queue.front();
      64           2 :         this->queue.pop();
      65           2 :         this->queue_mutex.unlock();
      66           2 :         handler(element);
      67             :     }
      68             :     else
      69             :     {
      70           2 :         this->handler = handler;
      71           2 :         this->queue_mutex.unlock();
      72             :     }
      73           4 : }
      74             : 
      75             : template<class T>
      76        7310 : bool ConcurrentQueue<T>::empty() const
      77             : {
      78       14620 :     std::lock_guard<std::mutex> lock(this->queue_mutex);
      79       14620 :     return this->queue.empty();
      80             : }
      81             : 
      82             : template<class T>
      83             : std::size_t ConcurrentQueue<T>::size() const
      84             : {
      85             :     std::lock_guard<std::mutex> lock(this->queue_mutex);
      86             :     return this->queue.size();
      87             : }
      88             : 
      89             : } // namespace Kinematics
      90             : } // namespace HLR