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);
 
  BaseQueue(uint16_t element_size, size_t length);
 
  ~BaseQueue();
 
  [[nodiscard]] void* operator[](uint32_t index);
 
  ErrorCode Push(const void* data);
 
  ErrorCode Peek(void* data);
 
  ErrorCode Pop(void* data = nullptr);
 
  int GetLastElementIndex() const;
 
  int GetFirstElementIndex() const;
 
  ErrorCode PushBatch(const void* data, size_t size);
 
  ErrorCode PopBatch(void* data, size_t size);
 
  ErrorCode PeekBatch(void* data, size_t size);
 
  ErrorCode Overwrite(const void* data);
 
  void Reset();
 
  [[nodiscard]] size_t Size() const;
 
  [[nodiscard]] size_t EmptySize() const;
 
  [[nodiscard]] size_t MaxSize() const { return length_; }
 
  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); }
 
  [[nodiscard]] size_t MaxSize() const { return length_; }
};
 
}  // namespace LibXR