uvco::Loop Class Reference

#include <loop.h>

Collaboration diagram for uvco::Loop:

Public Member Functions
	Loop (Scheduler::RunMode mode=Scheduler::RunMode::Deferred)
	Loop (const Loop &)=delete
	Loop (Loop &&)=delete
Loop &	operator= (const Loop &)=delete
Loop &	operator= (Loop &&)=delete
	~Loop ()
uv_loop_t *	uvloop () const
	Get a non-owned pointer to the loop.

Static Public Member Functions
static void	enqueue (std::coroutine_handle<> handle)

Private Member Functions
void	run ()
void	runOne ()

Static Private Member Functions
static Scheduler &	currentScheduler ()

Private Attributes
std::unique_ptr< uv_loop_t >	loop_
std::unique_ptr< Scheduler >	scheduler_

Static Private Attributes
static Loop *	defaultLoop = nullptr

Friends
void	runLoop (Loop &)

Detailed Description

Not used by user code! Use runMain() for the top-level interface.

A wrapper around a libuv event loop. uvloop() returns a reference to the loop, and run() starts the event loop. enqueue() schedules a coroutine to run on the default loop at a later time, enabling any part of uvco to easily schedule work on the current loop.

Typically this is only used by uvco's internal machinery. User code will pass around a reference to the loop.

Constructor & Destructor Documentation

Loop() [1/3]

uvco::Loop::Loop ( Scheduler::RunMode  mode = Scheduler::RunMode::Deferred )

explicit

    : loop_{std::make_unique<uv_loop_t>()},
      scheduler_{std::make_unique<Scheduler>(mode)} {
 
  if (defaultLoop != nullptr) {
    throw UvcoException(UV_EBUSY,
                        "Loop::Loop(): only one loop can be created.");
  }
 
  uv_loop_init(loop_.get());
  uv_loop_set_data(loop_.get(), scheduler_.get());
  scheduler_->setUpLoop(loop_.get());
  defaultLoop = this;
}

Loop() [2/3]

uvco::Loop::Loop ( const Loop &  )

delete

Loop() [3/3]

uvco::Loop::Loop ( Loop &&  )

delete

~Loop()

uvco::Loop::~Loop

(

)

            {
  scheduler_->close();
 
  // Run loop again so that all handles are closed.
  // A single turn is enough.
  runOne();
 
  // Now run all scheduled handles
  scheduler_->runAll();
 
  const uv_status status = uv_loop_close(loop_.get());
  if (0 != status) {
    fmt::print(stderr,
               "Loop::~Loop(): uv_loop_close() failed; there were "
               "still resources on the loop: {}\n",
               uv_strerror(status));
  }
  defaultLoop = nullptr;
}

Member Function Documentation

currentScheduler()

Scheduler & uvco::Loop::currentScheduler ( )

staticprivate

                                  {
  if (defaultLoop == nullptr) {
    throw UvcoException(UV_EINVAL, "Loop::getDefaultLoop(): no loop created.");
  }
  return *defaultLoop->scheduler_;
}

enqueue()

void uvco::Loop::enqueue ( std::coroutine_handle<>  handle )

static

                                               {
  currentScheduler().enqueue(handle);
  // If any handles are present, ensure that uv_run returns from waiting for I/O
  // soon.
  uv_stop(defaultLoop->uvloop());
}

operator=() [1/2]

Loop & uvco::Loop::operator= ( const Loop &  )

delete

operator=() [2/2]

Loop & uvco::Loop::operator= ( Loop &&  )

delete

run()

void uvco::Loop::run ( )

private

Run the event loop. This will serve all promises initialized before calling it.

               {
  while (!scheduler_->empty() || uv_loop_alive(loop_.get()) != 0) {
    runOne();
    // Run any left-over coroutines, and check if they schedule callbacks.
    scheduler_->runAll();
  }
}

runOne()

void uvco::Loop::runOne ( )

private

{ uv_run(loop_.get(), UV_RUN_ONCE); }

uvloop()

uv_loop_t * uvco::Loop::uvloop

(

)

const

Get a non-owned pointer to the loop.

{ return loop_.get(); }

Friends And Related Symbol Documentation

runLoop

void runLoop ( Loop &  loop )

friend

{ loop.run(); }

Member Data Documentation

defaultLoop

Loop * uvco::Loop::defaultLoop = nullptr

staticprivate

loop_

std::unique_ptr<uv_loop_t> uvco::Loop::loop_

private

scheduler_

std::unique_ptr<Scheduler> uvco::Loop::scheduler_

private

---

The documentation for this class was generated from the following files:

• uvco/loop/loop.h
• uvco/loop/loop.cc