Text-based IO help?

[ethindp]

I'm curious how I would perform text-based IO (i.e., read into a string). My initial attempt was something like:

    llfio::file_handle fh = llfio::file({}, absolute_path, mode, creation, caching, flags).value();
    std::string buffer;
    buffer.resize(fh.maximum_extent().value());
    const auto bytesread = llfio::read(fh, 0, {{reinterpret_cast<llfio::byte*>(buffer.data()), buffer.size()}}, std::chrono::minutes(1)).value();
    buffer.resize(bytesread);
    fh.close().value();
    return buffer;

However, I'm considering rewriting this to use std::span and std::as_writable_bytes. Just uncertain if there is a better way. For this example I'm reading an entire file into memory but even partial reads would be interesting. I am however worried about possible unnecessary copies/other performance degradation via this method (I don't think there are any, but I haven't thoroughly benchmarked things, so...). My desire to rewrite is purely because I'm not exactly a fan of reinterpret_cast unless it's absolutely necessary but that might just be me. :) What general advice is there for reading/writing types that we might not wish to treat as bytes if we know the (actual) type we wish to read/write (i.e. strings)?

[ned14]

Strings in C++ are currently just bytes, and std::span has some helper member functions to return a span of T as a span of bytes. So you could - if you wanted to - turn the string buffer into a span of char, take that into a span of bytes, read into that.

Or just do reinterpret cast as you currently do.

[ethindp]

What I now do is this:

namespace llfio = LLFIO_V2_NAMESPACE;
// ...
  llfio::file_handle fh{llfio::file({}, absolute_path, mode, creation, caching, flags).value()};
  std::string buffer;
  buffer.resize(fh.maximum_extent().value());
  auto buffer_view{std::as_writable_bytes(std::span{buffer})};
  const auto bytesread{
      llfio::read(fh, 0, {{buffer_view.data(), buffer_view.size()}}, std::chrono::minutes(1))
          .value()};
  if (bytesread == 0) {
    return "";
  }
  buffer.resize(bytesread);
  fh.close().value();
  return buffer;

I'm not sure if this has any performance overhead, or if I can get an even greater amount of performance out of it, but it's quite a nice, low-level API and I can see myself very much using llfio in the future. The trick will be figuring out the right tunables, but this works for now.