Serialize/Deserialize json on non-blocking file descriptor

[milasudril]

Is it possible to serialize/deserialize json when using non-blocking I/O?

For parsing, I imagine a parse_context, that contains the current state, and a function such as

void parse_ctxt::parse(std::span<char const>);

If the last } (or ] if the top-level obejct is an array) has been reached, The parse_context should contain a valid json object. Otherwise, it should contain a flag that indicates the status. The status could also indicate some error condition.

Example usage:

class json_reader
{
public:
  enum class parse_result{keep_going, completed};
  
  auto read_data()
  {
    std::array<char, 4096> buffer{};
    while(!ctxt.completed()) {
      auto res = read(fd, std::data(buffer), std::size(buffer));
      if(res == -1 && errno == EAGAIN)
      { return keep_going; }
      
      ctxt.parse(std::span{std::data(buffer), static_cast<size_t>(res)});
    }
    return completed;
  }
  
  auto take_result()
  { return std::move(ctxt.result()); }

private:
  int fd;
  parse_context ctxt;
};

The parse_context may also contain a value that indicates where in the buffer, the json object ended. This provides the options to

1. Continue to parse a different json object
2. Continue to read some other form of data
3. Treat it as an error condition if the block passed to parse was not entirely consumed