utl_tsqueue.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2020 VECTIONEER.
 */
 
#ifndef MOTORCORTEX_CORE_UTL_TSQUEUE_H
#define MOTORCORTEX_CORE_UTL_TSQUEUE_H
 
#include <condition_variable>
#include <mutex>
#include <queue>
 
template <typename T>
class ThreadSafeQueue {
public:
  ThreadSafeQueue() = default;
 
  void push(T new_value) {
    std::lock_guard<std::mutex> lk(mut_);
    data_queue_.push(std::move(new_value));
    data_cond_.notify_one();
  }
 
  void waitAndPop(T& value) {
    std::unique_lock<std::mutex> lk(mut_);
    data_cond_.wait(lk, [this] { return !data_queue_.empty() || destroy_; });
    if (!destroy_) {
      value = std::move(data_queue_.front());
      data_queue_.pop();
    }
  }
 
  std::shared_ptr<T> waitAndPop() {
    std::unique_lock<std::mutex> lk(mut_);
    data_cond_.wait(lk, [this] { return !data_queue_.empty() || destroy_; });
    if (!destroy_) {
      std::shared_ptr<T> res(std::make_shared<T>(std::move(data_queue_.front())));
      data_queue_.pop();
      return res;
    }
    return nullptr;
  }
 
  bool tryPop(T& value) {
    std::lock_guard<std::mutex> lk(mut_);
    if (data_queue_.empty()) {
      return false;
    }
    value = std::move(data_queue_.front());
    data_queue_.pop();
    return true;
  }
 
  std::shared_ptr<T> tryPop() {
    std::lock_guard<std::mutex> lk(mut_);
    if (data_queue_.empty()) {
      return std::shared_ptr<T>();
    }
    std::shared_ptr<T> res(std::make_shared<T>(std::move(data_queue_.front())));
    data_queue_.pop();
    return res;
  }
 
  bool empty() const {
    std::lock_guard<std::mutex> lk(mut_);
    return data_queue_.empty();
  }
 
  void destroy() {
    std::lock_guard<std::mutex> lk(mut_);
    destroy_ = true;
    data_cond_.notify_all();
  }
 
private:
  mutable std::mutex mut_;
  std::queue<T> data_queue_;
  std::condition_variable data_cond_;
  bool destroy_{false};
};
 
#endif // MOTORCORTEX_CORE_UTL_TSQUEUE_H