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)
  {
    const ErrorCode lock_ans = mutex_.Lock();
    if (lock_ans != ErrorCode::OK)
    {
      return lock_ans;
    }
 
    auto ans = queue_handle_.Push(data);
    if (ans == ErrorCode::OK)
    {
      semaphore_handle_.Post();
    }
    mutex_.Unlock();
    return ans;
  }
 
  ErrorCode Pop(Data &data, uint32_t timeout)
  {
    const ErrorCode wait_ans = semaphore_handle_.Wait(timeout);
    if (wait_ans == ErrorCode::OK)
    {
      const ErrorCode lock_ans = mutex_.Lock();
      if (lock_ans != ErrorCode::OK)
      {
        semaphore_handle_.Post();
        return lock_ans;
      }
 
      auto ans = queue_handle_.Pop(data);
      mutex_.Unlock();
      return ans;
    }
 
    return wait_ans;
  }
 
  ErrorCode Pop()
  {
    const ErrorCode lock_ans = mutex_.Lock();
    if (lock_ans != ErrorCode::OK)
    {
      return lock_ans;
    }
    auto ans = queue_handle_.Pop();
    mutex_.Unlock();
    return ans;
  }
 
  ErrorCode Pop(uint32_t timeout)
  {
    const ErrorCode wait_ans = semaphore_handle_.Wait(timeout);
    if (wait_ans == ErrorCode::OK)
    {
      const ErrorCode lock_ans = mutex_.Lock();
      if (lock_ans != ErrorCode::OK)
      {
        semaphore_handle_.Post();
        return lock_ans;
      }
 
      auto ans = queue_handle_.Pop();
      mutex_.Unlock();
      return ans;
    }
 
    return wait_ans;
  }
 
  ErrorCode PushFromCallback(const Data &data, bool in_isr)
  {
    UNUSED(in_isr);
    return Push(data);
  }
 
  size_t Size()
  {
    if (mutex_.Lock() != ErrorCode::OK)
    {
      return 0;
    }
    auto ans = queue_handle_.Size();
    mutex_.Unlock();
    return ans;
  }
 
  size_t EmptySize()
  {
    if (mutex_.Lock() != ErrorCode::OK)
    {
      return 0;
    }
    auto ans = queue_handle_.EmptySize();
    mutex_.Unlock();
    return ans;
  }
 
 private:
  Queue<Data> queue_handle_;    
  Mutex mutex_;                 
  Semaphore semaphore_handle_;  
};
 
}  // namespace LibXR