double_buffer.hpp

#pragma once
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstring>
 
#include "libxr_type.hpp"  // RawData
 
namespace LibXR
{ 
class DoubleBuffer
{
 public:
  explicit DoubleBuffer(const LibXR::RawData& raw_data) : size_(raw_data.size_ / 2)
  {
    buffer_[0] = static_cast<uint8_t*>(raw_data.addr_);
    buffer_[1] = static_cast<uint8_t*>(raw_data.addr_) + size_;
  }
 
  uint8_t* ActiveBuffer() { return buffer_[active_]; }
 
  uint8_t* PendingBuffer() { return buffer_[1 - active_]; }
 
  size_t Size() const { return size_; }
 
  void Switch()
  {
    if (pending_valid_)
    {
      active_ ^= 1;
      pending_valid_ = false;
    }
  }
 
  bool HasPending() const { return pending_valid_; }
 
  bool FillPending(const uint8_t* data, size_t len)
  {
    if (pending_valid_ || len > size_)
    {
      return false;
    }
    std::memcpy(PendingBuffer(), data, len);
    pending_len_ = len;
    pending_valid_ = true;
    return true;
  }
 
  bool FillActive(const uint8_t* data, size_t len)
  {
    if (len > size_)
    {
      return false;
    }
    std::memcpy(ActiveBuffer(), data, len);
    return true;
  }
 
  void EnablePending() { pending_valid_ = true; }
 
  size_t PendingLength() const { return pending_valid_ ? pending_len_ : 0; }
 
 private:
  uint8_t* buffer_[2];  
  size_t size_;         
  int active_ = 0;      
  bool pending_valid_ =
      false;                
  size_t pending_len_ = 0;  
};
}  // namespace LibXR