uvco::StreamBase::InStreamAwaiter_ Struct Reference

Collaboration diagram for uvco::StreamBase::InStreamAwaiter_:

Public Member Functions
	InStreamAwaiter_ (StreamBase &stream, std::span< char > buffer)
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::optional< std::coroutine_handle<> >	handle_

Constructor & Destructor Documentation

InStreamAwaiter_()

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

inlineexplicit

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

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->base = awaiter->buffer_.data();
  buf->len = awaiter->buffer_.size();
}

await_ready()

bool uvco::StreamBase::InStreamAwaiter_::await_ready

(

)

                                             {
  uv_status 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 {};
  }
  BOOST_ASSERT(status_);
  stream_.reader_.reset();
  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_) {
    auto handle = awaiter->handle_.value();
    awaiter->handle_.reset();
    Loop::enqueue(handle);
  }
  setData(stream, (void*)nullptr);
}

start_read()

void uvco::StreamBase::InStreamAwaiter_::start_read

(

)

                                            {
  uv_read_start(&stream_.stream(), StreamBase::InStreamAwaiter_::allocate,
                StreamBase::InStreamAwaiter_::onInStreamRead);
}

stop_read()

void uvco::StreamBase::InStreamAwaiter_::stop_read

(

)

                                           {
  uv_read_stop(&stream_.stream());
}

Member Data Documentation

buffer_

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

handle_

std::optional<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 files:

• uvco/stream.h
• uvco/stream.cc