queue.hpp

#pragma once
 
#include <cstddef>
#include <cstdio>
#include <cstring>
 
#include "libxr_def.hpp"
 
namespace LibXR
{
class BaseQueue
{
 public:
  BaseQueue(uint16_t element_size, size_t length, uint8_t *buffer)
      : queue_array_(buffer),
        ELEMENT_SIZE(element_size),
        length_(length),
        own_buffer_(false)
  {
  }
 
  BaseQueue(uint16_t element_size, size_t length)
      : queue_array_(new uint8_t[length * element_size]),
        ELEMENT_SIZE(element_size),
        length_(length),
        own_buffer_(true)
  {
  }
 
  ~BaseQueue()
  {
    if (own_buffer_)
    {
      delete[] queue_array_;
    }
  }
 
  [[nodiscard]] void *operator[](uint32_t index)
  {
    return &queue_array_[static_cast<size_t>(index * ELEMENT_SIZE)];
  }
 
  ErrorCode Push(const void *data)
  {
    ASSERT(data != nullptr);
 
    if (is_full_)
    {
      return ErrorCode::FULL;
    }
 
    memcpy(&queue_array_[tail_ * ELEMENT_SIZE], data, ELEMENT_SIZE);
 
    tail_ = (tail_ + 1) % length_;
    if (head_ == tail_)
    {
      is_full_ = true;
    }
 
    return ErrorCode::OK;
  }
 
  ErrorCode Peek(void *data)
  {
    ASSERT(data != nullptr);
 
    if (Size() > 0)
    {
      memcpy(data, &queue_array_[head_ * ELEMENT_SIZE], ELEMENT_SIZE);
      return ErrorCode::OK;
    }
    else
    {
      return ErrorCode::EMPTY;
    }
  }
 
  ErrorCode Pop(void *data = nullptr)
  {
    if (Size() == 0)
    {
      return ErrorCode::EMPTY;
    }
 
    if (data != nullptr)
    {
      memcpy(data, &queue_array_[head_ * ELEMENT_SIZE], ELEMENT_SIZE);
    }
    head_ = (head_ + 1) % length_;
    is_full_ = false;
    return ErrorCode::OK;
  }
 
  int GetLastElementIndex() const
  {
    if (Size() == 0)
    {
      return -1;
    }
    return static_cast<int>((tail_ + length_ - 1) % length_);
  }
 
  int GetFirstElementIndex() const
  {
    if (Size() == 0)
    {
      return -1;
    }
    return static_cast<int>(head_);
  }
 
  ErrorCode PushBatch(const void *data, size_t size)
  {
    ASSERT(data != nullptr);
 
    auto avail = EmptySize();
    if (avail < size)
    {
      return ErrorCode::FULL;
    }
 
    auto tmp = reinterpret_cast<const uint8_t *>(data);
 
    size_t first_part = LibXR::min(size, length_ - tail_);
    memcpy(&queue_array_[tail_ * ELEMENT_SIZE], tmp, first_part * ELEMENT_SIZE);
 
    if (size > first_part)
    {
      memcpy(queue_array_, &tmp[first_part * ELEMENT_SIZE],
             (size - first_part) * ELEMENT_SIZE);
    }
 
    tail_ = (tail_ + size) % length_;
    if (head_ == tail_)
    {
      is_full_ = true;
    }
    return ErrorCode::OK;
  }
 
  ErrorCode PopBatch(void *data, size_t size)
  {
    if (Size() < size)
    {
      return ErrorCode::EMPTY;
    }
 
    if (size == 0)
    {
      return ErrorCode::OK;
    }
    is_full_ = false;
 
    size_t first_part = LibXR::min(size, length_ - head_);
    if (data != nullptr)
    {
      auto tmp = reinterpret_cast<uint8_t *>(data);
      memcpy(tmp, &queue_array_[head_ * ELEMENT_SIZE], first_part * ELEMENT_SIZE);
      if (size > first_part)
      {
        memcpy(&tmp[first_part * ELEMENT_SIZE], queue_array_,
               (size - first_part) * ELEMENT_SIZE);
      }
    }
 
    head_ = (head_ + size) % length_;
    return ErrorCode::OK;
  }
 
  ErrorCode PeekBatch(void *data, size_t size)
  {
    ASSERT(data != nullptr);
 
    if (Size() < size)
    {
      return ErrorCode::EMPTY;
    }
 
    auto index = head_;
 
    auto tmp = reinterpret_cast<uint8_t *>(data);
 
    size_t first_part = LibXR::min(size, length_ - index);
    memcpy(tmp, &queue_array_[index * ELEMENT_SIZE], first_part * ELEMENT_SIZE);
 
    if (first_part < size)
    {
      memcpy(&tmp[first_part * ELEMENT_SIZE], queue_array_,
             (size - first_part) * ELEMENT_SIZE);
    }
 
    return ErrorCode::OK;
  }
 
  ErrorCode Overwrite(const void *data)
  {
    ASSERT(data != nullptr);
 
    head_ = tail_ = 0;
    is_full_ = false;
 
    memcpy(queue_array_, data, ELEMENT_SIZE * length_);
 
    tail_ = (tail_ + 1) % length_;
    if (head_ == tail_)
    {
      is_full_ = true;
    }
 
    return ErrorCode::OK;
  }
 
  void Reset()
  {
    head_ = tail_ = 0;
    is_full_ = false;
  }
 
  [[nodiscard]] size_t Size() const
  {
    if (is_full_)
    {
      return length_;
    }
    else if (tail_ >= head_)
    {
      return tail_ - head_;
    }
    else
    {
      return length_ + tail_ - head_;
    }
  }
 
  [[nodiscard]] size_t EmptySize() const { return length_ - Size(); }
 
  BaseQueue(const BaseQueue &) = delete;
  BaseQueue &operator=(const BaseQueue &) = delete;
  BaseQueue &operator=(BaseQueue &) = delete;
  BaseQueue &operator=(const BaseQueue &&) = delete;
  BaseQueue &operator=(BaseQueue &&) = delete;
 
  uint8_t *queue_array_;        
  const uint16_t ELEMENT_SIZE;  
  size_t head_ = 0;             
  size_t tail_ = 0;             
  bool is_full_ = false;        
  size_t length_;               
  bool own_buffer_ = false;     
};
 
template <typename Data>
class Queue : public BaseQueue
{
 public:
  Queue(size_t length) : BaseQueue(sizeof(Data), length) {}
 
  Queue(size_t length, uint8_t *buffer) : BaseQueue(sizeof(Data), length, buffer) {}
 
  Data &operator[](int32_t index)
  {
    if (index >= 0)
    {
      index = (head_ + index) % length_;
    }
    else
    {
      index = (tail_ + index + length_) % length_;
    }
 
    return *reinterpret_cast<Data *>(&queue_array_[index * ELEMENT_SIZE]);
  }
 
  ErrorCode Push(const Data &data) { return BaseQueue::Push(&data); }
 
  ErrorCode Pop(Data &data) { return BaseQueue::Pop(&data); }
 
  ErrorCode Pop() { return BaseQueue::Pop(); }
 
  ErrorCode Peek(Data &data) { return BaseQueue::Peek(&data); }
 
  ErrorCode PushBatch(const Data *data, size_t size)
  {
    return BaseQueue::PushBatch(data, size);
  }
 
  ErrorCode PopBatch(Data *data, size_t size) { return BaseQueue::PopBatch(data, size); }
 
  ErrorCode PeekBatch(Data *data, size_t size)
  {
    return BaseQueue::PeekBatch(data, size);
  }
 
  ErrorCode Overwrite(const Data &data) { return BaseQueue::Overwrite(&data); }
};
 
}  // namespace LibXR