Function write_internal

src/windows/libwinio.cpp:492–525

static Future<size_t> write_internal(
    const int_fd& fd, const void* buf, size_t size, IOType type)
{
  process::initialize();

  Promise<size_t>* promise = new Promise<size_t>();
  Future<size_t> future = promise->future();

  // We use a `std::shared_ptr`, so we can safely support canceling.
  auto overlapped = std::make_shared<IOOverlappedReadWrite>(
      IOOverlappedBase{OVERLAPPED{}, fd, type}, promise);

  enable_cancellation(fd, future, overlapped);

  // Start the asynchronous operation.
  const Result<size_t> result =
    os::write_async(fd, buf, size, &overlapped->base.overlapped);

  // If the request is pending, then we return immediately and have the
  // callback free the promise and overlapped.
  if (result.isNone()) {
    return future;
  }

  // In an error or immediate success, we have to manually set the promise
  // and free it.
  if (result.isError()) {
    promise->fail("os::write_async failed: " + result.error());
  } else if (result.isSome()) {
    promise->set(result.get());
  }
  delete promise;
  return future;
}


Future<size_t> read(const int_fd& fd, void* buf, size_t size)