uvco::Directory Class Reference

#include <fs.h>

Classes
struct	DirEnt

Public Member Functions
	Directory (const Directory &)=default
	Directory (Directory &&other) noexcept
Directory &	operator= (const Directory &)=delete
Directory &	operator= (Directory &&other) noexcept
	~Directory ()
Promise< std::vector< DirEnt > >	read (unsigned count=64)
	Read up to count directory entries.
Promise< unsigned int >	read (std::span< DirEnt > buffer)
	Read up to buffer.size() directory entries into that buffer.
Promise< void >	close ()
	Close the directory.

Static Public Member Functions
static Promise< void >	mkdir (const Loop &loop, std::string_view path, int mode=0755)
	Create a directory.
static Promise< void >	rmdir (const Loop &loop, std::string_view path)
	Remove a directory. It must be empty.
static Promise< Directory >	open (const Loop &loop, std::string_view path)
	Open a directory for reading.
static MultiPromise< DirEnt >	readAll (const Loop &loop, std::string_view path)
	Read all directory entries of the given directory.

Private Member Functions
	Directory (uv_loop_t *loop, uv_dir_t *dir)

Private Attributes
uv_loop_t *	loop_
uv_dir_t *	dir_

Constructor & Destructor Documentation

Directory() [1/3]

uvco::Directory::Directory ( const Directory &  )

default

Directory() [2/3]

uvco::Directory::Directory ( Directory &&  other )

noexcept

    : loop_{other.loop_}, dir_{other.dir_} {
  other.loop_ = nullptr;
  other.dir_ = nullptr;
}

~Directory()

uvco::Directory::~Directory

(

)

                      {
  if (dir_ != nullptr) {
    auto req = std::make_unique<uv_fs_t>();
    uv_fs_closedir(loop_, req.release(), dir_, nullptr);
    fmt::print(stderr, "Directory closed in dtor; this leaks memory. Please "
                       "use co_await close() instead\n");
  }
}

Directory() [3/3]

uvco::Directory::Directory ( uv_loop_t *  loop, uv_dir_t *  dir  )

inlineexplicitprivate

: loop_{loop}, dir_{dir} {}

Member Function Documentation

close()

Promise< void > uvco::Directory::close

(

)

Close the directory.

                               {
  FileOpAwaiter_ awaiter;
  uv_fs_closedir(loop_, &awaiter.req(), dir_, FileOpAwaiter_::uvCallback());
  co_await awaiter;
  dir_ = nullptr;
  co_return;
}

mkdir()

Promise< void > uvco::Directory::mkdir ( const Loop &  loop, std::string_view  path, int  mode = 0755  )

static

Create a directory.

                                         {
  FileOpAwaiter_ awaiter;
 
  uv_fs_mkdir(loop.uvloop(), &awaiter.req(), path.data(), mode,
              FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  co_return;
}

open()

Promise< Directory > uvco::Directory::open ( const Loop &  loop, std::string_view  path  )

static

Open a directory for reading.

                                                                        {
  FileOpAwaiter_ awaiter;
 
  uv_fs_opendir(loop.uvloop(), &awaiter.req(), path.data(),
                FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  co_return Directory{loop.uvloop(), (uv_dir_t *)awaiter.req().ptr};
}

operator=() [1/2]

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

delete

operator=() [2/2]

Directory & uvco::Directory::operator= ( Directory &&  other )

noexcept

                                                          {
  if (this == &other) {
    return *this;
  }
  loop_ = other.loop_;
  dir_ = other.dir_;
  other.loop_ = nullptr;
  other.dir_ = nullptr;
  return *this;
}

read() [1/2]

Promise< unsigned int > uvco::Directory::read

(

std::span< DirEnt >

buffer

)

Read up to buffer.size() directory entries into that buffer.

                                                            {
  // dirents vector must be declared before awaiter, because awaiter will free
  // contents of dirents.
  std::vector<uv_dirent_t> dirents{buffer.size()};
  dir_->dirents = dirents.data();
  dir_->nentries = dirents.size();
 
  FileOpAwaiter_ awaiter;
 
  uv_fs_readdir(loop_, &awaiter.req(), dir_, FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  unsigned int nentries = awaiter.req().result;
  for (unsigned i = 0; i < nentries; ++i) {
    buffer[i].name = dirents[i].name;
    buffer[i].type = dirents[i].type;
  }
  co_return nentries;
}

read() [2/2]

Promise< std::vector< Directory::DirEnt > > uvco::Directory::read

(

unsigned

count = 64

)

Read up to count directory entries.

                                                                  {
  std::vector<DirEnt> result{count};
  const unsigned int size = co_await read(result);
  result.resize(size);
  co_return result;
}

readAll()

MultiPromise< Directory::DirEnt > uvco::Directory::readAll ( const Loop &  loop, std::string_view  path  )

static

Read all directory entries of the given directory.

                                                                        {
  FileOpAwaiter_ awaiter;
  uv_dirent_t dirent;
  const std::string pathCopy{path};
 
  uv_fs_scandir(loop.uvloop(), &awaiter.req(), pathCopy.c_str(), 0,
                FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
  while (UV_EOF != uv_fs_scandir_next(&awaiter.req(), &dirent)) {
    co_yield DirEnt{dirent.name, dirent.type};
  }
}

rmdir()

Promise< void > uvco::Directory::rmdir ( const Loop &  loop, std::string_view  path  )

static

Remove a directory. It must be empty.

                                                                    {
  FileOpAwaiter_ awaiter;
 
  uv_fs_rmdir(loop.uvloop(), &awaiter.req(), path.data(),
              FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  co_return;
}

Member Data Documentation

dir_

uv_dir_t* uvco::Directory::dir_

private

loop_

uv_loop_t* uvco::Directory::loop_

private

---

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

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