uvco::FsWatch Class Reference

#include <fs.h>

Classes
struct	FileEvent
struct	FsWatchAwaiter_

Public Member Functions
	FsWatch (const FsWatch &)=delete
	FsWatch (FsWatch &&)=default
FsWatch &	operator= (const FsWatch &)=delete
FsWatch &	operator= (FsWatch &&)=default
	~FsWatch ()
MultiPromise< FileEvent >	watch ()
Promise< void >	stopWatch (MultiPromise< FileEvent > watcher)
Promise< void >	close ()

Static Public Member Functions
static Promise< FsWatch >	create (const Loop &loop, std::string_view path)
static Promise< FsWatch >	createRecursive (const Loop &loop, std::string_view path)

Private Member Functions
	FsWatch ()
MultiPromise< FileEvent >	watch_ ()

Static Private Member Functions
static Promise< FsWatch >	createWithFlag (const Loop &loop, std::string_view path, uv_fs_event_flags flags)
static void	onFsWatcherEvent (uv_fs_event_t *handle, const char *path, int events, uv_status status)

Private Attributes
std::unique_ptr< uv_fs_event_t >	uv_handle_ {}

Constructor & Destructor Documentation

FsWatch() [1/3]

uvco::FsWatch::FsWatch ( const FsWatch &  )

delete

FsWatch() [2/3]

uvco::FsWatch::FsWatch ( FsWatch &&  )

default

~FsWatch()

uvco::FsWatch::~FsWatch

(

)

Destructor. If the watch is still active, it is stopped. However, it's still required to call close() before dropping the FsWatch.

                  {
  if (!uv_handle_) {
    return;
  }
  BOOST_ASSERT_MSG(dataIsNull(uv_handle_.get()),
                   "don't drop an FsWatch while a watch() generator is "
                   "running (use stopWatch()!)");
  uv_fs_event_stop(uv_handle_.get());
}

FsWatch() [3/3]

uvco::FsWatch::FsWatch ( )

private

: uv_handle_{std::make_unique<uv_fs_event_t>()} {}

Member Function Documentation

close()

Promise< void > uvco::FsWatch::close

(

)

                             {
  co_await closeHandle(uv_handle_.get());
  uv_handle_.reset();
}

create()

Promise< FsWatch > uvco::FsWatch::create ( const Loop &  loop, std::string_view  path  )

static

Create aa new FsWatch instance. The path is the file or directory to watch.

                                                                      {
  return createWithFlag(loop, path, {});
}

createRecursive()

Promise< FsWatch > uvco::FsWatch::createRecursive ( const Loop &  loop, std::string_view  path  )

static

Create a recursive watch. NOTE! This is only supported on macOS and Windows; see https://docs.libuv.org/en/v1.x/fs_event.html#c.uv_fs_event_start.

                                                               {
  return createWithFlag(loop, path, UV_FS_EVENT_RECURSIVE);
}

createWithFlag()

Promise< FsWatch > uvco::FsWatch::createWithFlag ( const Loop &  loop, std::string_view  path, uv_fs_event_flags  flags  )

staticprivate

                                                                  {
  FsWatch fsWatch;
  uv_fs_event_t &uv_handle = *fsWatch.uv_handle_;
  const uv_status initStatus = uv_fs_event_init(loop.uvloop(), &uv_handle);
  if (initStatus != 0) {
    throw UvcoException{
        initStatus,
        "uv_fs_event_init returned error while initializing FsWatch"};
  }
  const auto startStatus =
      callWithNullTerminated<uv_status>(path, [&](std::string_view safePath) {
        return uv_fs_event_start(&uv_handle, onFsWatcherEvent, safePath.data(),
                                 flags);
      });
  if (startStatus != 0) {
    uv_fs_event_stop(&uv_handle);
    // This works with the current Loop::~Loop implementation.
    co_await closeHandle(&uv_handle);
    fsWatch.uv_handle_.reset();
    throw UvcoException{
        startStatus, "uv_fs_event_start returned error while starting FsWatch"};
  }
  co_return fsWatch;
}

onFsWatcherEvent()

void uvco::FsWatch::onFsWatcherEvent ( uv_fs_event_t *  handle, const char *  path, int  events, uv_status  status  )

staticprivate

                                                             {
  BOOST_ASSERT(events < 4);
  if (dataIsNull(handle)) {
    // No watcher generator set up yet.
    return;
  }
  auto *awaiter = getData<FsWatchAwaiter_>(handle);
  if (status == 0) {
    awaiter->addEvent(FileEvent{std::string{path}, (uv_fs_event)events});
  } else {
    awaiter->addError(status);
  }
  awaiter->schedule();
}

operator=() [1/2]

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

delete

operator=() [2/2]

FsWatch & uvco::FsWatch::operator= ( FsWatch &&  )

default

stopWatch()

Promise< void > uvco::FsWatch::stopWatch

(

MultiPromise< FileEvent >

watcher

)

                                                                       {
  auto *awaiter = getData<FsWatchAwaiter_>(uv_handle_.get());
  awaiter->stop();
  co_await watcher;
}

watch()

MultiPromise< FsWatch::FileEvent > uvco::FsWatch::watch

(

)

                                              {
  if (!dataIsNull(uv_handle_.get())) {
    throw UvcoException(UV_EBUSY, "FsWatch::watch() is already active!");
  }
  return watch_();
}

watch_()

MultiPromise< FsWatch::FileEvent > uvco::FsWatch::watch_ ( )

private

                                               {
  FsWatchAwaiter_ awaiter;
  setData(uv_handle_.get(), &awaiter);
  ZeroAtExit<void> zeroAtExit{&uv_handle_->data};
 
  while (co_await awaiter) {
    co_yield awaiter.events_.get();
  }
}

Member Data Documentation

uv_handle_

std::unique_ptr<uv_fs_event_t> uvco::FsWatch::uv_handle_ {}

private

{};

---

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

• uvco/fs.h
• uvco/fs.cc