libxr_rw.hpp

#pragma once
 
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <utility>
 
#include "chunk_queue.hpp"
#include "libxr_cb.hpp"
#include "libxr_def.hpp"
#include "libxr_type.hpp"
#include "lockfree_queue.hpp"
#include "mutex.hpp"
#include "semaphore.hpp"
 
namespace LibXR
{
 
template <typename... Args>
class Operation
{
 public:
  enum class OperationType : uint8_t
  {
    CALLBACK,
    BLOCK,
    POLLING,
    NONE
  };
 
  enum class OperationPollingStatus : uint8_t
  {
    READY,
    RUNNING,
    DONE
  };
 
  Operation() : type(OperationType::NONE) {}
 
  Operation(Semaphore &sem, uint32_t timeout = UINT32_MAX) : type(OperationType::BLOCK)
  {
    data.sem_info.sem = &sem;
    data.sem_info.timeout = timeout;
  }
 
  Operation(Callback<Args...> &callback) : type(OperationType::CALLBACK)
  {
    data.callback = &callback;
  }
 
  Operation(OperationPollingStatus &status) : type(OperationType::POLLING)
  {
    data.status = &status;
  }
 
  Operation &operator=(const Operation &op)
  {
    if (this != &op)
    {
      type = op.type;
      switch (type)
      {
        case OperationType::CALLBACK:
          data.callback = op.data.callback;
          break;
        case OperationType::BLOCK:
          data.sem_info.sem = op.data.sem_info.sem;
          data.sem_info.timeout = op.data.sem_info.timeout;
          break;
        case OperationType::POLLING:
          data.status = op.data.status;
          break;
        case OperationType::NONE:
          break;
      }
    }
    return *this;
  }
 
  Operation &operator=(Operation &&op) noexcept
  {
    if (this != &op)
    {
      type = op.type;
      switch (type)
      {
        case OperationType::CALLBACK:
          data.callback = op.data.callback;
          break;
        case OperationType::BLOCK:
          data.sem_info.sem = op.data.sem_info.sem;
          data.sem_info.timeout = op.data.sem_info.timeout;
          break;
        case OperationType::POLLING:
          data.status = op.data.status;
          break;
        case OperationType::NONE:
          break;
      }
    }
    return *this;
  }
 
  Operation(const Operation &op) : type(op.type)
  {
    switch (type)
    {
      case OperationType::CALLBACK:
        data.callback = op.data.callback;
        break;
      case OperationType::BLOCK:
        data.sem = op.data.sem;
        data.timeout = op.data.timeout;
        break;
      case OperationType::POLLING:
        data.status = op.data.status;
        break;
      case OperationType::NONE:
        break;
    }
  }
 
  Operation(Operation &&op) noexcept : type(op.type)
  {
    switch (type)
    {
      case OperationType::CALLBACK:
        data.callback = op.data.callback;
        break;
      case OperationType::BLOCK:
        data.sem_info.sem = op.data.sem_info.sem;
        data.sem_info.timeout = op.data.sem_info.timeout;
        break;
      case OperationType::POLLING:
        data.status = op.data.status;
        break;
      case OperationType::NONE:
        break;
    }
  }
 
  void UpdateStatus(bool in_isr, Args &&...args)
  {
    switch (type)
    {
      case OperationType::CALLBACK:
        data.callback->Run(in_isr, std::forward<Args>(args)...);
        break;
      case OperationType::BLOCK:
        data.sem_info.sem->PostFromCallback(in_isr);
        break;
      case OperationType::POLLING:
        *data.status = OperationPollingStatus::DONE;
        break;
      case OperationType::NONE:
        break;
    }
  }
 
  void MarkAsRunning()
  {
    if (type == OperationType::POLLING)
    {
      *data.status = OperationPollingStatus::RUNNING;
    }
  }
 
  union
  {
    Callback<Args...> *callback;
    struct
    {
      Semaphore *sem;
      uint32_t timeout;
    } sem_info;
    OperationPollingStatus *status;
  } data;
 
  OperationType type;
};
 
class ReadPort;
class WritePort;
 
typedef Operation<ErrorCode> ReadOperation;
 
typedef Operation<ErrorCode> WriteOperation;
 
typedef ErrorCode (*WriteFun)(WritePort &port);
 
typedef ErrorCode (*ReadFun)(ReadPort &port);
 
class ReadInfoBlock
{
 public:
  RawData data_;      
  ReadOperation op_;  
 
  ReadInfoBlock(RawData data, ReadOperation &&op) : data_(data), op_(std::move(op)) {}
 
  ReadInfoBlock() : data_(), op_() {}
};
 
class ReadPort
{
 public:
  ReadFun read_fun_ = nullptr;
  LockFreeQueue<ReadInfoBlock> *queue_block_ = nullptr;
  BaseQueue *queue_data_ = nullptr;
  size_t read_size_ = 0;
  Mutex mutex_;
 
  ReadPort(size_t queue_size = 3, size_t buffer_size = 128)
      : queue_block_(new LockFreeQueue<ReadInfoBlock>(queue_size)),
        queue_data_(new BaseQueue(1, buffer_size))
  {
  }
 
  size_t EmptySize() { return queue_data_->EmptySize(); }
 
  size_t Size() { return queue_data_->Size(); }
 
  bool Readable() { return read_fun_ != nullptr; }
 
  ReadPort &operator=(ReadFun fun)
  {
    read_fun_ = fun;
    return *this;
  }
 
  void UpdateStatus(bool in_isr, ErrorCode ans, ReadInfoBlock &info, uint32_t size)
  {
    read_size_ = size;
    info.op_.UpdateStatus(in_isr, std::forward<ErrorCode>(ans));
  }
 
  void UpdateStatus(ReadInfoBlock &info) { info.op_.MarkAsRunning(); }
 
  ErrorCode operator()(RawData data, ReadOperation &op)
  {
    if (Readable())
    {
      if (data.size_ == 0)
      {
        op.UpdateStatus(false, ErrorCode::OK);
        if (op.type == ReadOperation::OperationType::BLOCK)
        {
          return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
        }
        return ErrorCode::OK;
      }
 
      Mutex::LockGuard lock_guard(mutex_);
 
      ReadInfoBlock block = {data, std::move(op)};
      if (queue_block_->Push(block) != ErrorCode::OK)
      {
        return ErrorCode::FULL;
      }
 
      auto ans = read_fun_(*this);
      if (op.type == ReadOperation::OperationType::BLOCK)
      {
        return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
      }
      else
      {
        return ans;
      }
    }
    else
    {
      return ErrorCode::NOT_SUPPORT;
    }
  }
 
  void ProcessPendingReads()
  {
    ReadInfoBlock block;
    while (queue_block_->Peek(block) == ErrorCode::OK)
    {
      if (queue_data_->Size() >= block.data_.size_)
      {
        queue_data_->PopBatch(block.data_.addr_, block.data_.size_);
        read_size_ = block.data_.size_;
        block.op_.UpdateStatus(true, ErrorCode::OK);
        queue_block_->Pop();
      }
      else
      {
        break;
      }
    }
  }
 
  void Reset()
  {
    queue_block_->Reset();
    queue_data_->Reset();
    read_size_ = 0;
  }
};
 
class WritePort
{
 public:
  typedef struct
  {
    WriteOperation op;
    uint32_t size;
  } WriteInfo;
  WriteFun write_fun_ = nullptr;
  LockFreeQueue<WriteInfo> *queue_info_;
  LockFreeQueue<uint8_t> *queue_data_;
  Mutex mutex_;
  size_t write_size_ = 0;
 
  WritePort(size_t queue_size = 3, size_t block_size = 128)
      : queue_info_(new LockFreeQueue<WriteInfo>(queue_size)),
        queue_data_(new LockFreeQueue<uint8_t>(block_size))
  {
  }
 
  size_t EmptySize() { return queue_data_->EmptySize(); }
 
  size_t Size() { return queue_data_->Size(); }
 
  bool Writable() { return write_fun_ != nullptr; }
 
  WritePort &operator=(WriteFun fun)
  {
    write_fun_ = fun;
    return *this;
  }
 
  void UpdateStatus(bool in_isr, ErrorCode ans, WriteOperation &op, uint32_t size)
  {
    write_size_ = size;
    op.UpdateStatus(in_isr, std::forward<ErrorCode>(ans));
  }
 
  void UpdateStatus(WriteOperation &op) { op.MarkAsRunning(); }
 
  ErrorCode operator()(ConstRawData data, WriteOperation &op)
  {
    if (Writable())
    {
      if (data.size_ == 0)
      {
        op.UpdateStatus(false, ErrorCode::OK);
        if (op.type == WriteOperation::OperationType::BLOCK)
        {
          return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
        }
        return ErrorCode::OK;
      }
 
      Mutex::LockGuard lock_guard(mutex_);
 
      if (queue_data_->EmptySize() < data.size_ || queue_info_->EmptySize() < 1)
      {
        return ErrorCode::FULL;
      }
 
      auto ans = queue_data_->PushBatch(reinterpret_cast<const uint8_t *>(data.addr_),
                                        data.size_);
 
      ans = queue_info_->Push(
          WriteInfo{std::forward<WriteOperation>(op), static_cast<uint32_t>(data.size_)});
 
      ans = write_fun_(*this);
      if (op.type == WriteOperation::OperationType::BLOCK)
      {
        return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
      }
      else
      {
        return ans;
      }
    }
    else
    {
      return ErrorCode::NOT_SUPPORT;
    }
  }
 
  void Reset()
  {
    queue_info_->Reset();
    queue_data_->Reset();
    write_size_ = 0;
  }
};
 
class STDIO
{
 public:
  // NOLINTBEGIN
  static inline ReadPort *read_ = nullptr;    
  static inline WritePort *write_ = nullptr;  
#if LIBXR_PRINTF_BUFFER_SIZE > 0
  static inline char
      printf_buff_[LIBXR_PRINTF_BUFFER_SIZE];  
#endif
  // NOLINTEND
 
  static int Printf(const char *fmt, ...)  // NOLINT
  {
#if LIBXR_PRINTF_BUFFER_SIZE > 0
    if (!STDIO::write_ || !STDIO::write_->Writable())
    {
      return -1;
    }
 
    static LibXR::Mutex mutex;  // NOLINT
 
    LibXR::Mutex::LockGuard lock_guard(mutex);
 
    va_list args;
    va_start(args, fmt);
    int len = vsnprintf(STDIO::printf_buff_, LIBXR_PRINTF_BUFFER_SIZE, fmt, args);
    va_end(args);
 
    // Check result and limit length
    if (len < 0)
    {
      return -1;
    }
    if (static_cast<size_t>(len) >= LIBXR_PRINTF_BUFFER_SIZE)
    {
      len = LIBXR_PRINTF_BUFFER_SIZE - 1;
    }
 
    ConstRawData data = {reinterpret_cast<const uint8_t *>(STDIO::printf_buff_),
                         static_cast<size_t>(len)};
 
    static WriteOperation op;  // NOLINT
    return static_cast<int>(STDIO::write_->operator()(data, op));
#else
    UNUSED(fmt);
    return 0;
#endif
  }
};
}  // namespace LibXR