uvco::StreamBase::InStreamAwaiter_ Struct Reference

Collaboration diagram for uvco::StreamBase::InStreamAwaiter_:

Public Member Functions
	InStreamAwaiter_ (StreamBase &stream, std::span< char > buffer)
	~InStreamAwaiter_ ()
bool	await_ready ()
bool	await_suspend (std::coroutine_handle<> handle)
size_t	await_resume ()
void	start_read ()
void	stop_read ()

Static Public Member Functions
static void	allocate (uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)
static void	onInStreamRead (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)

Public Attributes
StreamBase &	stream_
std::span< char >	buffer_
std::optional< ssize_t >	status_
std::coroutine_handle	handle_

Constructor & Destructor Documentation

InStreamAwaiter_()

uvco::StreamBase::InStreamAwaiter_::InStreamAwaiter_ ( StreamBase & stream, std::span< char > buffer )

inlineexplicit

      : stream_{stream}, buffer_{buffer} {}

~InStreamAwaiter_()

uvco::StreamBase::InStreamAwaiter_::~InStreamAwaiter_

(

)

                                              {
  if (stream_.underlying() != nullptr &&
      1 == uv_is_active((const uv_handle_t *)stream_.underlying())) {
    stop_read();
  }
  // A cancelled read is signalled to the callback by a nullptr.
  if (stream_.stream_ != nullptr) {
    resetData(&stream_.stream());
  }
  stream_.reader_ = nullptr;
}

Member Function Documentation

allocate()

void uvco::StreamBase::InStreamAwaiter_::allocate ( uv_handle_t * handle, size_t suggested_size, uv_buf_t * buf )

static

                                                           {
  const InStreamAwaiter_ *awaiter = getData<InStreamAwaiter_>(handle);
  BOOST_ASSERT(awaiter != nullptr);
  *buf = uv_buf_init(const_cast<char *>(awaiter->buffer_.data()),
                     awaiter->buffer_.size());
}

await_ready()

bool uvco::StreamBase::InStreamAwaiter_::await_ready

(

)

                                             {
  const int state = uv_is_readable(&stream_.stream());
  if (state == 1) {
    // If data is available, the callback onInStreamRead will be called
    // immediately. In that case we don't have to wait.
    start_read();
    stop_read();
  }
  return status_.has_value();
}

await_resume()

size_t uvco::StreamBase::InStreamAwaiter_::await_resume

(

)

                                                {
  if (!status_ && !stream_.stream_) {
    return 0;
  }
  BOOST_ASSERT(status_);
  stream_.reader_ = nullptr;
  if (status_ && *status_ == UV_EOF) {
    return 0;
  }
  if (status_ && *status_ < 0) {
    throw UvcoException{static_cast<uv_status>(*status_),
                        "StreamBase::read() encountered error"};
  }
  BOOST_ASSERT(status_.value() >= 0);
  return static_cast<size_t>(status_.value());
}

await_suspend()

bool uvco::StreamBase::InStreamAwaiter_::await_suspend

(

std::coroutine_handle<>

handle

)

                                  {
  BOOST_ASSERT(dataIsNull(&stream_.stream()));
  setData(&stream_.stream(), this);
  handle_ = handle;
  stream_.reader_ = handle;
  start_read();
  return true;
}

onInStreamRead()

void uvco::StreamBase::InStreamAwaiter_::onInStreamRead ( uv_stream_t * stream, ssize_t nread, const uv_buf_t * buf )

static

                                                                      {
  auto *awaiter = getData<InStreamAwaiter_>(stream);
  BOOST_ASSERT(awaiter != nullptr);
  awaiter->stop_read();
  awaiter->status_ = nread;
 
  if (awaiter->handle_) {
    Loop::enqueue(awaiter->handle_);
    awaiter->handle_ = nullptr;
  }
  setData(stream, (void *)nullptr);
}

start_read()

void uvco::StreamBase::InStreamAwaiter_::start_read

(

)

                                            {
  const uv_status result =
      uv_read_start(&stream_.stream(), StreamBase::InStreamAwaiter_::allocate,
                    StreamBase::InStreamAwaiter_::onInStreamRead);
  if (result != 0) {
    throw UvcoException{
        result, "StreamBase::read() encountered error in uv_read_start()"};
  }
}

stop_read()

void uvco::StreamBase::InStreamAwaiter_::stop_read

(

)

                                           {
  // stream_.stream_ may be null if the stream has been closed in the meantime.
  if (stream_.stream_) {
    uv_read_stop(&stream_.stream());
  }
}

Member Data Documentation

buffer_

std::span<char> uvco::StreamBase::InStreamAwaiter_::buffer_

handle_

std::coroutine_handle uvco::StreamBase::InStreamAwaiter_::handle_

status_

std::optional<ssize_t> uvco::StreamBase::InStreamAwaiter_::status_

stream_

StreamBase& uvco::StreamBase::InStreamAwaiter_::stream_

---

The documentation for this struct was generated from the following file:

• uvco/stream.cc