stdio.hpp

#pragma once
 
#include <cstddef>
#include <string_view>
#include <tuple>
#include <utility>
 
#include "mutex.hpp"
#include "print.hpp"
#include "read_port.hpp"
#include "write_port.hpp"
 
namespace LibXR
{
 
class STDIO
{
 public:
  // Shared global stdio binding state.
  // 共享的全局 stdio 绑定状态。
  // NOLINTBEGIN
  static inline ReadPort* read_ = nullptr;    
  static inline WritePort* write_ = nullptr;  
  static inline LibXR::Mutex* write_mutex_ =
      nullptr;  
  static inline LibXR::WritePort::Stream* write_stream_ =
      nullptr;  
  // NOLINTEND
 
 private:
  // Compiled-format bridge shared by the brace and printf frontends.
  // brace 与 printf 两个前端共用的编译格式桥接层。
 
  class CompiledSink
  {
   public:
    explicit CompiledSink(WritePort::Stream& stream);
 
    [[nodiscard]] ErrorCode Write(std::string_view chunk);
 
    [[nodiscard]] size_t RetainedSize() const { return retained_size_; }
 
   private:
    WritePort::Stream& stream_;  
    size_t retained_size_ = 0;  
    bool saturated_ = false;  
  };
 
  // Type-erased bridge for one compiled STDIO call.
  // 一次编译格式 STDIO 调用的类型擦除桥接函数。
  using CompiledWriteFun = ErrorCode (*)(void* context, CompiledSink& sink);
 
  template <typename CompiledFormat, typename... Args>
  struct CompiledCall
  {
    const CompiledFormat& format;  
    std::tuple<Args&&...> args;  
 
    [[nodiscard]] static ErrorCode Write(void* context, CompiledSink& sink)
    {
      auto& compiled_call = *static_cast<CompiledCall*>(context);
      return std::apply(
          [&](auto&&... unpacked) -> ErrorCode
          {
            return Print::Write(sink, compiled_call.format,
                                std::forward<decltype(unpacked)>(unpacked)...);
          },
          compiled_call.args);
    }
  };
 
  [[nodiscard]] static int WriteCompiledToStream(WritePort::Stream& stream,
                                                 void* context,
                                                 CompiledWriteFun write_fun);
 
  [[nodiscard]] static int WriteCompiledSession(void* context, CompiledWriteFun write_fun);
 
  template <typename Call>
  [[nodiscard]] static int RunCompiledSession(Call& call)
  {
    if (!BeginWriteSession())
    {
      return -1;
    }
 
    return WriteCompiledSession(&call, &Call::Write);
  }
 
  template <typename CompiledFormat, typename... Args>
  [[nodiscard]] static int RunCompiled(const CompiledFormat& format, Args&&... args)
  {
    CompiledCall<CompiledFormat, Args...> call{
        format, std::forward_as_tuple(std::forward<Args>(args)...)};
    return RunCompiledSession(call);
  }
 
  [[nodiscard]] static bool BeginWriteSession();
 
  [[nodiscard]] static int FinishWriteSession(WritePort::Stream& stream,
                                              size_t retained_size,
                                              ErrorCode format_result);
 
 public:
 
  template <Print::Text Source, typename... Args>
  static int Print(Args&&... args)
  {
    constexpr LibXR::Format<Source> format{};
    return RunCompiled(format, std::forward<Args>(args)...);
  }
 
  template <Print::Text Source, typename... Args>
  static int Printf(Args&&... args)
  {
    constexpr auto format = Print::Printf::Build<Source>();
    return RunCompiled(format, std::forward<Args>(args)...);
  }
};
 
}  // namespace LibXR