File objects that are opened from existing FileDescriptor objects. More...

#include <FDFile.hxx>

Inheritance diagram for cosmos::FDFile:

Public Member Functions
	FDFile (const FileDescriptor fd, const AutoCloseFD auto_close)
	Wrap the given file descriptor applying the specified auto-close behaviour.

	FDFile (FDFile &&other) noexcept

FDFile &	operator= (FDFile &&other) noexcept

void	open (const FileDescriptor fd, const AutoCloseFD auto_close)
	Takes the already open file descriptor fd and operates on it.

void	close () override
	Close the current file object.

Public Member Functions inherited from cosmos::FileBase
	FileBase (const FileBase &)=delete

FileBase &	operator= (const FileBase &)=delete

bool	isOpen () const
	Returns whether currently a FileDescriptor is opened.

FileDescriptor	fd () const
	Allows access to the underlying fd with const semantics.

void	truncate (const off_t length)

Public Member Functions inherited from cosmos::StreamIO
	StreamIO (FileDescriptor &fd)

	StreamIO (const StreamIO &)=delete

StreamIO &	operator= (const StreamIO &)=delete

StreamIO &	operator= (StreamIO &&) noexcept

size_t	read (void *buf, size_t length)
	Read up to `length` bytes from the file into `buf`.

size_t	write (const void *buf, size_t length)
	Write up to `length` bytes from `buf` into the underlying file.

size_t	write (const std::string_view data)
	string_view wrapper around write(const void*, size_t).

void	readAll (void *buf, size_t length)
	Read all `length` bytes from the underlying file.

void	readAll (std::string &s, size_t length)
	Like readAll(void*, size_t) using an STL string.

void	writeAll (const void *buf, size_t length)
	Write all `length` bytes into the underlying file.

void	writeAll (const std::string_view data)
	string_view wrapper around writeAll(const void*, size_t).

bool	read (ReadIOVector &iovec)
	Read data from file into a vector of data regions.

bool	write (WriteIOVector &iovec)
	Write data to file from a vector of data regions.

void	readAll (ReadIOVector &iovec)
	Read into all data regions specified in `iovec`.

void	writeAll (WriteIOVector &iovec)
	Write all data regions specified in `iovec`.

off_t	seek (const SeekType type, off_t off)
	Seek to the given offset based on the given offset `type`.

off_t	seekFromStart (off_t off)
	Seek to the given offset relative to the start of the file.

off_t	seekFromCurrent (off_t off)
	Seek to the given offset relative to the current file position.

off_t	seekFromEnd (off_t off)
	Seek to the given offset relative to the end of the file.

Protected Attributes
AutoCloseFD	m_auto_close

Protected Attributes inherited from cosmos::FileBase
FileDescriptor	m_fd

Protected Attributes inherited from cosmos::StreamIO
FileDescriptor &	m_stream_fd

Additional Inherited Members
Public Types inherited from cosmos::StreamIO
enum class	SeekType : int { SET = SEEK_SET , CUR = SEEK_CUR , END = SEEK_END , DATA = SEEK_DATA , HOLE = SEEK_HOLE }
	Different methods for changing the file read/write position. More...

Protected Member Functions inherited from cosmos::FileBase
	FileBase (const FileDescriptor fd=FileDescriptor{})

	FileBase (FileBase &&other) noexcept

FileBase &	operator= (FileBase &&other) noexcept

Detailed Description

File objects that are opened from existing FileDescriptor objects.

This is a thin file type that simply wraps an existing FileDescriptor object. Taking ownership of the provided file descriptor is optional and needs to be decided explicitly. If ownership is not taken then the file descriptor will never be closed by the implementation.

Definition at line 15 of file FDFile.hxx.

Constructor & Destructor Documentation

◆ FDFile() [1/2]

cosmos::FDFile::FDFile	(	const FileDescriptor	fd,
		const AutoCloseFD	auto_close )

inline

Wrap the given file descriptor applying the specified auto-close behaviour.

Definition at line 22 of file FDFile.hxx.

                                                                      {
                open(fd, auto_close);
        }

◆ FDFile() [2/2]

cosmos::FDFile::FDFile ( FDFile && other )

inlinenoexcept

Definition at line 26 of file FDFile.hxx.

                                        {
                *this = std::move(other);
        }

◆ ~FDFile()

cosmos::FDFile::~FDFile ( )

Definition at line 6 of file FDFile.cxx.

                {
        if (!m_auto_close) {
                // only close() here if we're not actually closing. This
                // cannot fail. If we have to close() then let the base class
                // destructor do that.
                close();
        }
}

Member Function Documentation

◆ close()

void cosmos::FDFile::close ( )

inlineoverridevirtual

Close the current file object.

If currently no file is open then this does nothing. If currently an external FileDescriptor is wrapped and auto-close is not set then only the object's state will be invalidated. Otherwise the referenced file descriptor will also be closed on OS-level.

Reimplemented from cosmos::FileBase.

Reimplemented in cosmos::TimerFD< CLOCK >.

Definition at line 62 of file FDFile.hxx.

                              {
 
                if (!m_auto_close) {
                        m_fd.reset();
                        m_auto_close = AutoCloseFD{true};
                        return;
                }
 
                FileBase::close();
        }

◆ open()

void cosmos::FDFile::open	(	const FileDescriptor	fd,
		const AutoCloseFD	auto_close )

inline

Takes the already open file descriptor fd and operates on it.

The caller is responsible for invalidating fd, if desired, and that the file descriptor is not used in conflicting ways.

The parameter auto_close determines whether the File object will take ownership of the file descriptor, or not. If so then the file descriptor is closed on OS level if deemed necessary by the implementation.

Definition at line 50 of file FDFile.hxx.

                                                                         {
                m_fd = fd;
                m_auto_close = auto_close;
        }

◆ operator=()

FDFile & cosmos::FDFile::operator= ( FDFile && other )

inlinenoexcept

Definition at line 30 of file FDFile.hxx.

                                                   {
                m_auto_close = other.m_auto_close;
                other.m_auto_close = AutoCloseFD{true};
 
                FileBase::operator=(std::move(other));
                return *this;
        }

Member Data Documentation

◆ m_auto_close

AutoCloseFD cosmos::FDFile::m_auto_close

protected

Definition at line 74 of file FDFile.hxx.

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

include/fs/FDFile.hxx
src/fs/FDFile.cxx

Public Member Functions

Protected Attributes

Additional Inherited Members