File objects that are opened by pathname. More...

#include <File.hxx>

Inheritance diagram for cosmos::File:

Public Member Functions
	File (const SysString path, const OpenMode mode)
	Open a file without special flags (close-on-exec will be set).

	File (const SysString path, const OpenMode mode, const OpenFlags flags, const std::optional< FileMode > fmode={})
	Open a file using specific OpenFlags, potentially creating it first using the given `fmode`.

	File (const DirFD dir_fd, const SysString path, const OpenMode mode, const OpenFlags flags, const std::optional< FileMode > fmode={})
	Open the given path relative to the given directory file descriptor `dir_fd`.

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

void	open (const SysString path, const OpenMode mode)

void	open (const SysString path, const OpenMode mode, const OpenFlags flags, const std::optional< FileMode > fmode={})
	Open the given path applying the specified mode and flags.

void	open (const DirFD dir_fd, const SysString path, const OpenMode mode)

void	open (const DirFD dir_fd, const SysString path, const OpenMode mode, const OpenFlags flags, const std::optional< FileMode > fmode={})
	Open the given path relative to the given directory file descriptor `dir_fd`.

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

Public Member Functions inherited from cosmos::FDFile
	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.

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

Protected Attributes inherited from cosmos::FDFile
AutoCloseFD	m_auto_close

Protected Attributes inherited from cosmos::FileBase
FileDescriptor	m_fd

Protected Attributes inherited from cosmos::StreamIO
FileDescriptor &	m_stream_fd

Detailed Description

File objects that are opened by pathname.

On the level of this type the means to open a file by pathname are provided. This also allows to create new files depending on the used OpenFlags. As a special case opening file by name relative to an existing DirFD is possible.

This is the typical File type to use when there are no special circumstances.

Definition at line 23 of file File.hxx.

Constructor & Destructor Documentation

◆ File() [1/4]

cosmos::File::File	(	const SysString	path,
		const OpenMode	mode )

inline

Open a file without special flags (close-on-exec will be set).

Definition at line 30 of file File.hxx.

30 :

31 File{path, mode, OpenFlags{OpenFlag::CLOEXEC}} {}

cosmos::OpenFlags

BitMask< OpenFlag > OpenFlags

Collection of OpenFlag used for opening files.

Definition types.hxx:96

◆ File() [2/4]

cosmos::File::File	(	const SysString	path,
		const OpenMode	mode,
		const OpenFlags	flags,
		const std::optional< FileMode >	fmode = {} )

inline

Open a file using specific OpenFlags, potentially creating it first using the given fmode.

Warning: If used for creating a file, then you need to specify also the FileMode in that case. An exception will the thrown if this condition is violated.

Definition at line 39 of file File.hxx.

                                                            {}) {
                open(path, mode, flags, fmode);
        }

◆ File() [3/4]

cosmos::File::File	(	const DirFD	dir_fd,
		const SysString	path,
		const OpenMode	mode,
		const OpenFlags	flags,
		const std::optional< FileMode >	fmode = {} )

inline

Open the given path relative to the given directory file descriptor dir_fd.

See also: open(const DirFD, const SysString, const OpenFlags, const std::optional<FileMode>).

Definition at line 48 of file File.hxx.

                                                                                   {}) {
                open(dir_fd, path, mode, flags, fmode);
        }

◆ File() [4/4]

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

inline

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

Definition at line 54 of file File.hxx.

                                                                    :
                FDFile{fd, auto_close}
        {}

Member Function Documentation

◆ open() [1/5]

void cosmos::File::open	(	const DirFD	dir_fd,
		const SysString	path,
		const OpenMode	mode )

inline

See also: open(const DirFD, const SysString, const OpenMode, const OpenFlags, const std::optional<FileMode>).

Definition at line 74 of file File.hxx.

                                                                                 {
                open(dir_fd, path, mode, {OpenFlag::CLOEXEC});
        }

◆ open() [2/5]

void cosmos::File::open	(	const DirFD	dir_fd,
		const SysString	path,
		const OpenMode	mode,
		const OpenFlags	flags,
		const std::optional< FileMode >	fmode = {} )

Open the given path relative to the given directory file descriptor dir_fd.

See also: fs::open_at().

Definition at line 14 of file File.cxx.

                                                   {
 
        close();
        m_fd = fs::open_at(dir_fd, path, mode, flags, fmode);
}

◆ open() [3/5]

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;
        }

◆ open() [4/5]

void cosmos::File::open	(	const SysString	path,
		const OpenMode	mode )

inline

See also: File(const SysString, const OpenMode).

Definition at line 61 of file File.hxx.

                                                             {
                return open(path, mode, {OpenFlag::CLOEXEC});
        }

◆ open() [5/5]

void cosmos::File::open	(	const SysString	path,
		const OpenMode	mode,
		const OpenFlags	flags,
		const std::optional< FileMode >	fmode = {} )

Open the given path applying the specified mode and flags.

If in flags the CREATE bit is set then you must specify also fmode, otherwise an exception is thrown.

Definition at line 7 of file File.cxx.

                                                   {
 
        close();
        m_fd = fs::open(path, mode, flags, fmode);
}

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

include/fs/File.hxx
src/fs/File.cxx

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ File() [1/4]

◆ File() [2/4]

◆ File() [3/4]

◆ File() [4/4]

Member Function Documentation

◆ open() [1/5]

◆ open() [2/5]

◆ open() [3/5]

◆ open() [4/5]

◆ open() [5/5]