lock_queue.hpp

#pragma once
 
#include <cstdint>
 
#include "libxr_def.hpp"
#include "mutex.hpp"
#include "queue.hpp"
#include "semaphore.hpp"
 
namespace LibXR
{
 
template <typename Data>
class LockQueue
{
 public:
  LockQueue(size_t length) : queue_handle_(length) {}
 
  ~LockQueue() {}
 
  ErrorCode Push(const Data &data)
  {
    mutex_.Lock();
    auto ans = queue_handle_.Push(data);
    if (ans == ErrorCode::OK)
    {
      semaphore_handle_.Post();
    }
    mutex_.Unlock();
    return ans;
  }
 
  ErrorCode Pop(Data &data, uint32_t timeout)
  {
    if (semaphore_handle_.Wait(timeout) == ErrorCode::OK)
    {
      mutex_.Lock();
      auto ans = queue_handle_.Pop(data);
      mutex_.Unlock();
      return ans;
    }
    else
    {
      return ErrorCode::TIMEOUT;
    }
  }
 
  ErrorCode Pop()
  {
    mutex_.Lock();
    auto ans = queue_handle_.Pop();
    mutex_.Unlock();
    return ans;
  }
 
  ErrorCode Pop(uint32_t timeout)
  {
    if (semaphore_handle_.Wait(timeout) == ErrorCode::OK)
    {
      mutex_.Lock();
      auto ans = queue_handle_.Pop();
      mutex_.Unlock();
      return ans;
    }
    else
    {
      return ErrorCode::TIMEOUT;
    }
  }
 
  ErrorCode PushFromCallback(const Data &data, bool in_isr)
  {
    UNUSED(in_isr);
    return Push(data);
  }
 
  size_t Size()
  {
    mutex_.Lock();
    auto ans = queue_handle_.Size();
    mutex_.Unlock();
    return ans;
  }
 
  size_t EmptySize()
  {
    mutex_.Lock();
    auto ans = queue_handle_.EmptySize();
    mutex_.Unlock();
    return ans;
  }
 
 private:
  Queue<Data> queue_handle_;    
  Mutex mutex_;                 
  Semaphore semaphore_handle_;  
};
 
}  // namespace LibXR