uvco::File Class Reference

A file descriptor. More...

#include <fs.h>

Public Member Functions
Promise< size_t >	read (std::string &buffer, int64_t offset=-1)
Promise< size_t >	write (std::string_view buffer, int64_t offset=-1)
uv_file	file () const
	Access the libuv file handle.
Promise< void >	close ()
	Close a file asynchronously.

Static Public Member Functions
static Promise< File >	open (const Loop &loop, std::string_view path, int flags=0, int mode=0644)
static Promise< void >	unlink (const Loop &loop, std::string_view path)

Private Member Functions
	File (uv_loop_t *loop, uv_file file)

Private Attributes
uv_loop_t *	loop_
uv_file	file_

Detailed Description

A file descriptor.

Constructor & Destructor Documentation

File()

uvco::File::File ( uv_loop_t *  loop, uv_file  file  )

inlineprivate

: loop_{loop}, file_(file) {}

Member Function Documentation

close()

Promise< void > uvco::File::close

(

)

Close a file asynchronously.

                          {
  FileOpAwaiter_ awaiter;
  auto &req = awaiter.req();
 
  uv_fs_close(loop_, &req, file(), FileOpAwaiter_::uvCallback());
 
  file_ = -1;
 
  co_await awaiter;
}

file()

uv_file uvco::File::file

(

)

const

Access the libuv file handle.

                         {
  BOOST_ASSERT(file_ >= 0);
  return file_;
}

open()

Promise< File > uvco::File::open ( const Loop &  loop, std::string_view  path, int  flags = 0, int  mode = 0644  )

static

Open a file asynchronously; flags and mode are optional and analogous to open(2).

                                   {
  FileOpAwaiter_ awaiter;
 
  uv_fs_open(loop.uvloop(), &awaiter.req(), path.data(), flags, mode,
             FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  const auto fileDesc = static_cast<uv_file>(awaiter.req().result);
 
  co_return File{loop.uvloop(), fileDesc};
}

read()

Promise< size_t > uvco::File::read	(	std::string &	buffer,
		int64_t	offset = -1
	)

Read up to buffer.size() bytes into that buffer, starting at offset (if offset >= 0) or at the current file position.

buffer is resized to the number of bytes read, if it could not be filled completely; The number of bytes read is also returned.

TODO: generalize to any buffer type.

                                                            {
  FileOpAwaiter_ awaiter;
  size_t result = 0;
 
  std::array<uv_buf_t, 1> bufs{};
  bufs[0].base = buffer.data();
  bufs[0].len = buffer.length();
 
  uv_fs_read(loop_, &awaiter.req(), file(), bufs.data(), 1, offset,
             FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  result = awaiter.req().result;
  buffer.resize(result);
  co_return result;
}

unlink()

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

static

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

write()

Promise< size_t > uvco::File::write	(	std::string_view	buffer,
		int64_t	offset = -1
	)

Write contents of buffer to the underlying file at offset.

TODO: generalize to any buffer type.

                                                                 {
  FileOpAwaiter_ awaiter;
  size_t result = 0;
 
  std::array<uv_buf_t, 1> bufs{};
  // Unfortunately necessary: const_cast
  bufs[0].base = const_cast<char *>(buffer.data());
  bufs[0].len = buffer.length();
 
  uv_fs_write(loop_, &awaiter.req(), file(), bufs.data(), 1, offset,
              FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  result = awaiter.req().result;
  co_return result;
}

Member Data Documentation

file_

uv_file uvco::File::file_

private

loop_

uv_loop_t* uvco::File::loop_

private

---

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

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