Specialization of FileBase for managing temporary files. More...

#include <TempFile.hxx>

Inheritance diagram for cosmos::TempFile:

Public Member Functions
	TempFile (const SysString _template, const OpenFlags flags=OpenFlags{OpenFlag::CLOEXEC})

TempFile &	operator= (TempFile &&other) noexcept

void	close () override
	Close the current file object.

void	open (const SysString _template, const OpenFlags flags=OpenFlags{OpenFlag::CLOEXEC})

const std::string &	path () const
	Returns the expanded path to the temporary file.

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 Member Functions
void	unlinkPath ()

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

	FileBase (FileBase &&other) noexcept

FileBase &	operator= (FileBase &&other) noexcept

Protected Attributes
std::string	m_tmp_path

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...

Detailed Description

Specialization of FileBase for managing temporary files.

Creates a named temporary file in a template path and manages the lifetime of the resulting file descriptor and of the file on file system level.

Upon close() both the file descriptor will be closed and the file on disk will be unlinked.

See also: cosmos::fs::make_tempfile() for details about the structure of the _template path.

Definition at line 20 of file TempFile.hxx.

Constructor & Destructor Documentation

◆ TempFile()

cosmos::TempFile::TempFile	(	const SysString	_template,
		const OpenFlags	flags = OpenFlags{OpenFlag::CLOEXEC} )

inlineexplicit

Definition at line 26 of file TempFile.hxx.

                                                                                      {OpenFlag::CLOEXEC}) {
                open(_template, flags);
        }

◆ ~TempFile()

cosmos::TempFile::~TempFile ( )

Definition at line 8 of file TempFile.cxx.

                    {
        try {
                close();
        } catch (const std::exception &e) {
                noncritical_error("Failed to close TmpFile", e);
        }
}

Member Function Documentation

◆ close()

void cosmos::TempFile::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.

Definition at line 42 of file TempFile.hxx.

                              {
                try {
                        FileBase::close();
                } catch(...) {
                        unlinkPath();
                        throw;
                }
 
                unlinkPath();
        }

◆ open()

void cosmos::TempFile::open	(	const SysString	_template,
		const OpenFlags	flags = OpenFlags{OpenFlag::CLOEXEC} )

inline

Definition at line 53 of file TempFile.hxx.

                                                                              {OpenFlag::CLOEXEC}) {
                close();
 
                auto [fd, path] = fs::make_tempfile(_template, flags);
                m_fd = fd;
                m_tmp_path = path;
        }

◆ operator=()

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

inlinenoexcept

Definition at line 32 of file TempFile.hxx.

                                                       {
                m_tmp_path = other.m_tmp_path;
                other.m_tmp_path.clear();
 
                FileBase::operator=(std::move(other));
                return *this;
        }

◆ path()

const std::string & cosmos::TempFile::path ( ) const

Returns the expanded path to the temporary file.

This is only valid if currently a temporary file is open. Otherwise a UsageError will be thrown.

Definition at line 16 of file TempFile.cxx.

                                      {
        if (!m_tmp_path.empty())
                return m_tmp_path;
 
        cosmos_throw (UsageError("accessed path for closed TempFile"));
        return m_tmp_path; // to silence compiler warning
}

◆ unlinkPath()

void cosmos::TempFile::unlinkPath ( )

inlineprotected

Definition at line 70 of file TempFile.hxx.

                          {
                if (!m_tmp_path.empty()) {
                        try {
                                fs::unlink_file(m_tmp_path);
                        } catch(...) {
                                m_tmp_path.clear();
                                throw;
                        }
                        m_tmp_path.clear();
                }
        }

Member Data Documentation

◆ m_tmp_path

std::string cosmos::TempFile::m_tmp_path

protected

Definition at line 84 of file TempFile.hxx.

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

include/fs/TempFile.hxx
src/fs/TempFile.cxx

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members