ReadPort class for handling read operations. More...

#include <libxr_rw.hpp>

Inheritance diagram for LibXR::ReadPort:

Collaboration diagram for LibXR::ReadPort:

Public Types
enum class	BusyState : uint32_t { IDLE = 0 , PENDING = 1 , EVENT = UINT32_MAX }

Public Member Functions
	ReadPort (size_t buffer_size=128)
	Constructs a ReadPort with queue sizes.

virtual size_t	EmptySize ()
	获取队列的剩余可用空间。 Gets the remaining available space in the queue.

virtual size_t	Size ()
	获取当前队列的已使用大小。 Gets the currently used size of the queue.

bool	Readable ()
	Checks if read operations are supported.

ReadPort &	operator= (ReadFun fun)
	赋值运算符重载，用于设置读取函数。 Overloaded assignment operator to set the read function.

void	Finish (bool in_isr, ErrorCode ans, ReadInfoBlock &info, uint32_t size)
	更新读取操作的状态。 Updates the status of the read operation.

void	MarkAsRunning (ReadInfoBlock &info)
	标记读取操作为运行中。 Marks the read operation as running.

ErrorCode	operator() (RawData data, ReadOperation &op)
	读取操作符重载，用于执行读取操作。 Overloaded function call operator to perform a read operation.

virtual void	ProcessPendingReads (bool in_isr)
	Processes pending reads.

virtual void	Reset ()
	Resets the ReadPort.

Data Fields
ReadFun	read_fun_ = nullptr

LockFreeQueue< uint8_t > *	queue_data_ = nullptr

size_t	read_size_ = 0

ReadInfoBlock	info_

std::atomic< BusyState >	busy_ {BusyState::IDLE}

Detailed Description

ReadPort class for handling read operations.

处理读取操作的ReadPort类。

Definition at line 268 of file libxr_rw.hpp.

Member Enumeration Documentation

◆ BusyState

enum class LibXR::ReadPort::BusyState : uint32_t

strong

Definition at line 271 of file libxr_rw.hpp.

  {
    IDLE = 0,
    PENDING = 1,
    EVENT = UINT32_MAX
  };

Constructor & Destructor Documentation

◆ ReadPort()

ReadPort::ReadPort ( size_t buffer_size = 128 )

Constructs a ReadPort with queue sizes.

以指定队列大小构造ReadPort。

Parameters

queue_size	Number of queued operations.
buffer_size	Size of each buffer.

Definition at line 10 of file libxr_rw.cpp.

    : queue_data_(buffer_size > 0 ? new(std::align_val_t(LIBXR_CACHE_LINE_SIZE))
                                        LockFreeQueue<uint8_t>(buffer_size)
                                  : nullptr)
{
}

Member Function Documentation

◆ EmptySize()

size_t ReadPort::EmptySize ( )

virtual

获取队列的剩余可用空间。 Gets the remaining available space in the queue.

该函数返回 queue_block_ 中当前可用的空闲空间大小。 This function returns the size of the available empty space in queue_block_.

Returns: 返回队列的空闲大小（单位：字节）。 Returns the empty size of the queue (in bytes).

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 17 of file libxr_rw.cpp.

{
  ASSERT(queue_data_ != nullptr);
  return queue_data_->EmptySize();
}

◆ Finish()

void ReadPort::Finish	(	bool	in_isr,
		ErrorCode	ans,
		ReadInfoBlock &	info,
		uint32_t	size )

更新读取操作的状态。 Updates the status of the read operation.

该函数用于在读取操作过程中更新 read_size_ 并调用 UpdateStatus 方法更新 info.op_ 的状态。 This function updates read_size_ and calls UpdateStatus on info.op_ during a read operation.

Parameters

in_isr	指示是否在中断上下文中执行。 Indicates whether the operation is executed in an interrupt context.
ans	错误码，用于指示操作的结果。 Error code indicating the result of the operation.
info	需要更新状态的 `ReadInfoBlock` 引用。 Reference to the `ReadInfoBlock` whose status needs to be updated.
size	读取的数据大小。 The size of the read data.

Definition at line 37 of file libxr_rw.cpp.

{
  read_size_ = size;
  busy_.store(BusyState::IDLE, std::memory_order_release);
  info.op.UpdateStatus(in_isr, std::forward<ErrorCode>(ans));
}

◆ MarkAsRunning()

void ReadPort::MarkAsRunning ( ReadInfoBlock & info )

标记读取操作为运行中。 Marks the read operation as running.

该函数用于将 info.op_ 标记为运行状态，以指示当前正在进行读取操作。 This function marks info.op_ as running to indicate an ongoing read operation.

Parameters

info	需要更新状态的 `ReadInfoBlock` 引用。 Reference to the `ReadInfoBlock` whose status needs to be updated.

Definition at line 44 of file libxr_rw.cpp.

44{ info.op.MarkAsRunning(); }

LibXR::Operation::MarkAsRunning

void MarkAsRunning()

标记操作为运行状态。 Marks the operation as running.

Definition libxr_rw.hpp:202

◆ operator()()

ErrorCode ReadPort::operator()	(	RawData	data,
		ReadOperation &	op )

读取操作符重载，用于执行读取操作。 Overloaded function call operator to perform a read operation.

该函数检查端口是否可读，并根据 data.size_ 和 op 的类型执行不同的操作。 This function checks if the port is readable and performs different actions based on data.size_ and the type of op.

Parameters

data	包含要读取的数据。 Contains the data to be read.
op	读取操作对象，包含操作类型和同步机制。 Read operation object containing the operation type and synchronization mechanism.

Returns: 返回操作的 ErrorCode，指示操作结果。 Returns an ErrorCode indicating the result of the operation.

Definition at line 46 of file libxr_rw.cpp.

{
  if (Readable())
  {
    BusyState is_busy = busy_.load(std::memory_order_relaxed);
 
    if (is_busy == BusyState::PENDING)
    {
      return ErrorCode::BUSY;
    }
 
    while (true)
    {
      busy_.store(BusyState::IDLE, std::memory_order_release);
 
      if (queue_data_ != nullptr)
      {
        auto readable_size = queue_data_->Size();
 
        if (readable_size >= data.size_ && readable_size != 0)
        {
          auto ans =
              queue_data_->PopBatch(reinterpret_cast<uint8_t*>(data.addr_), data.size_);
          UNUSED(ans);
          read_size_ = data.size_;
          ASSERT(ans == ErrorCode::OK);
          if (op.type != ReadOperation::OperationType::BLOCK)
          {
            op.UpdateStatus(false, ErrorCode::OK);
          }
          return ErrorCode::OK;
        }
      }
 
      info_ = ReadInfoBlock{data, op};
 
      op.MarkAsRunning();
 
      auto ans = read_fun_(*this);
 
      if (ans != ErrorCode::OK)
      {
        BusyState expected = BusyState::IDLE;
        if (busy_.compare_exchange_weak(expected, BusyState::PENDING,
                                        std::memory_order_acq_rel,
                                        std::memory_order_acquire))
        {
          break;
        }
        else
        {
          continue;
        }
      }
      else
      {
        read_size_ = data.size_;
        if (op.type != ReadOperation::OperationType::BLOCK)
        {
          op.UpdateStatus(false, ErrorCode::OK);
        }
        return ErrorCode::OK;
      }
    }
 
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    else
    {
      return ErrorCode::OK;
    }
  }
  else
  {
    return ErrorCode::NOT_SUPPORT;
  }
}

◆ operator=()

ReadPort & ReadPort::operator= ( ReadFun fun )

赋值运算符重载，用于设置读取函数。 Overloaded assignment operator to set the read function.

该函数允许使用 ReadFun 类型的函数对象赋值给 ReadPort，从而设置 read_fun_。 This function allows assigning a ReadFun function object to ReadPort, setting read_fun_.

Parameters

fun	要分配的读取函数。 The read function to be assigned.

Returns: 返回自身的引用，以支持链式调用。 Returns a reference to itself for chaining.

Definition at line 31 of file libxr_rw.cpp.

{
  read_fun_ = fun;
  return *this;
}

◆ ProcessPendingReads()

void ReadPort::ProcessPendingReads ( bool in_isr )

virtual

Processes pending reads.

处理挂起的读取请求。

Parameters

in_isr 指示是否在中断上下文中执行。 Indicates whether the operation is executed in an interrupt context.

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 126 of file libxr_rw.cpp.

{
  ASSERT(queue_data_ != nullptr);
 
  if (in_isr)
  {
    auto is_busy = busy_.load(std::memory_order_relaxed);
 
    if (is_busy == BusyState::PENDING)
    {
      if (queue_data_->Size() >= info_.data.size_)
      {
        if (info_.data.size_ > 0)
        {
          auto ans = queue_data_->PopBatch(reinterpret_cast<uint8_t*>(info_.data.addr_),
                                           info_.data.size_);
          UNUSED(ans);
          ASSERT(ans == ErrorCode::OK);
        }
        Finish(in_isr, ErrorCode::OK, info_, info_.data.size_);
      }
    }
    else if (is_busy == BusyState::IDLE)
    {
      busy_.store(BusyState::EVENT, std::memory_order_release);
    }
  }
  else
  {
    if (busy_.load(std::memory_order_relaxed) == BusyState::PENDING)
    {
      if (queue_data_->Size() >= info_.data.size_)
      {
        if (info_.data.size_ > 0)
        {
          auto ans = queue_data_->PopBatch(reinterpret_cast<uint8_t*>(info_.data.addr_),
                                           info_.data.size_);
          UNUSED(ans);
          ASSERT(ans == ErrorCode::OK);
        }
        Finish(in_isr, ErrorCode::OK, info_, info_.data.size_);
      }
    }
  }
}

◆ Readable()

bool ReadPort::Readable ( )

Checks if read operations are supported.

检查是否支持读取操作。

Definition at line 29 of file libxr_rw.cpp.

29{ return read_fun_ != nullptr; }

◆ Reset()

void ReadPort::Reset ( )

virtual

Resets the ReadPort.

重置ReadPort。

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 172 of file libxr_rw.cpp.

{
  ASSERT(queue_data_ != nullptr);
  queue_data_->Reset();
}

◆ Size()

size_t ReadPort::Size ( )

virtual

获取当前队列的已使用大小。 Gets the currently used size of the queue.

该函数返回 queue_block_ 当前已占用的空间大小。 This function returns the size of the space currently used in queue_block_.

Returns: 返回队列的已使用大小（单位：字节）。 Returns the used size of the queue (in bytes).

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 23 of file libxr_rw.cpp.

{
  ASSERT(queue_data_ != nullptr);
  return queue_data_->Size();
}

Field Documentation

◆ busy_

std::atomic<BusyState> LibXR::ReadPort::busy_ {BusyState::IDLE}

Definition at line 282 of file libxr_rw.hpp.

282{BusyState::IDLE};

◆ info_

ReadInfoBlock LibXR::ReadPort::info_

Definition at line 281 of file libxr_rw.hpp.

◆ queue_data_

LockFreeQueue<uint8_t>* LibXR::ReadPort::queue_data_ = nullptr

Definition at line 279 of file libxr_rw.hpp.

◆ read_fun_

ReadFun LibXR::ReadPort::read_fun_ = nullptr

Definition at line 278 of file libxr_rw.hpp.

◆ read_size_

size_t LibXR::ReadPort::read_size_ = 0

Definition at line 280 of file libxr_rw.hpp.

The documentation for this class was generated from the following files:

src/core/libxr_rw.hpp
src/core/libxr_rw.cpp

Public Types

Public Member Functions

Data Fields

Detailed Description

Member Enumeration Documentation

◆ BusyState

Constructor & Destructor Documentation

◆ ReadPort()

Member Function Documentation

◆ EmptySize()

◆ Finish()

◆ MarkAsRunning()

◆ operator()()

◆ operator=()

◆ ProcessPendingReads()

◆ Readable()

◆ Reset()

◆ Size()

Field Documentation

◆ busy_

◆ info_

◆ queue_data_

◆ read_fun_

◆ read_size_