esp_tx_double_buffer.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "double_buffer.hpp"
#include "flag.hpp"
#include "libxr_assert.hpp"
#include "operation.hpp"
 
namespace LibXR
{
 
class ESPTxDoubleBuffer
{
 public:
  ESPTxDoubleBuffer() = default;
 
  void Init(RawData storage)
  {
    bytes_.Init(storage);
    Reset();
  }
 
  void Reset()
  {
    bytes_.Reset();
    ClearActive();
    ClearPending();
  }
 
  uint8_t* ActiveBuffer() const { return bytes_.ActiveBuffer(); }
 
  uint8_t* PendingBuffer() const { return bytes_.PendingBuffer(); }
 
  size_t BufferSize() const { return bytes_.Size(); }
 
  bool HasActive() const { return active_valid_; }
 
  bool HasPending() const { return pending_valid_.IsSet(); }
 
  size_t ActiveLength() const { return active_length_; }
 
  size_t ActiveOffset() const { return active_offset_; }
 
  void SetActiveOffset(size_t offset) { active_offset_ = offset; }
 
  WriteInfoBlock& ActiveInfo() { return active_info_; }
 
  const WriteInfoBlock& ActiveInfo() const { return active_info_; }
 
  WriteInfoBlock& PendingInfo() { return pending_info_; }
 
  const WriteInfoBlock& PendingInfo() const { return pending_info_; }
 
  void LoadActive(size_t size, const WriteInfoBlock& info)
  {
    active_length_ = size;
    active_offset_ = 0U;
    active_info_ = info;
    active_valid_ = true;
  }
 
  void LoadPending(size_t size, const WriteInfoBlock& info)
  {
    pending_length_ = size;
    pending_info_ = info;
    pending_valid_.Set();
  }
 
  bool PromotePending()
  {
    if (!pending_valid_.TestAndClear())
    {
      return false;
    }
 
    bytes_.FlipActiveBlock();
    active_length_ = pending_length_;
    active_offset_ = 0U;
    active_info_ = pending_info_;
    active_valid_ = true;
    pending_length_ = 0U;
    pending_info_ = {};
    return true;
  }
 
  void ClearActive()
  {
    active_length_ = 0U;
    active_offset_ = 0U;
    active_info_ = {};
    active_valid_ = false;
  }
 
  void ClearPending()
  {
    pending_valid_.Clear();
    pending_length_ = 0U;
    pending_info_ = {};
  }
 
 private:
  DoubleBuffer bytes_{};        
  size_t active_length_ = 0U;   
  size_t pending_length_ = 0U;  
  size_t active_offset_ = 0U;   
  WriteInfoBlock active_info_ = {};   
  WriteInfoBlock pending_info_ = {};  
  bool active_valid_ =
      false;  
  Flag::Atomic
      pending_valid_{};  
};
 
}  // namespace LibXR