uvco::File Class Reference

A file descriptor. More...

#include <fs.h>

Public Member Functions
	File (const File &)=delete
	File (File &&other) noexcept
File &	operator= (const File &)=delete
File &	operator= (File &&other) noexcept
	~File ()
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.
void	close ()
	Close a file.

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() [1/3]

uvco::File::File ( const File & )

delete

File() [2/3]

uvco::File::File ( File && other )

noexcept

                                {
  if (this == &other) {
    return;
  }
  loop_ = other.loop_;
  file_ = other.file_;
  other.file_ = -1;
}

~File()

uvco::File::~File

(

)

{ close(); }

File() [3/3]

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

inlineprivate

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

Member Function Documentation

close()

void uvco::File::close

(

)

Close a file.

                 {
  if (file_ != -1) {
    uv_fs_close(loop_, new uv_fs_t{}, file(), FileOpAwaiter_::uvCallback());
  }
  file_ = -1;
}

file()

uv_file uvco::File::file ( ) const

nodiscard

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;
 
  const std::string path_str(path);
  uv_fs_open(loop.uvloop(), &awaiter.req(), path_str.c_str(), flags, mode,
             FileOpAwaiter_::uvCallback());
 
  co_await awaiter;
 
  const auto fileDesc = static_cast<uv_file>(awaiter.req().result);
 
  co_return File{loop.uvloop(), fileDesc};
}

operator=() [1/2]

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

delete

operator=() [2/2]

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

noexcept

                                           {
  if (this == &other) {
    return *this;
  }
  close();
  loop_ = other.loop_;
  file_ = other.file_;
  other.file_ = -1;
  return *this;
}

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.

The provided buffer must be pre-sized to the desired number of bytes to read. The number of bytes read will be at most buffer.length(). After the operation, buffer is resized to the actual number of bytes read.

Parameters

buffer	A pre-sized string to read data into.
offset	The offset in the file to read from. Defaults to -1 (current file position).

Returns

The number of bytes read.

TODO: generalize to any buffer type.

                                                            {
  FileOpAwaiter_ awaiter;
  size_t result = 0;
 
  std::array<uv_buf_t, 1> bufs{};
  bufs[0] = uv_buf_init(buffer.data(), 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;
 
  const std::string path_str(path);
  uv_fs_unlink(loop.uvloop(), &awaiter.req(), path_str.c_str(),
               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] = uv_buf_init(const_cast<char *>(buffer.data()), 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