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;
 
  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