trio::FileStreamImpl Class Reference

#include <FileStreamImpl.h>

Inheritance diagram for trio::FileStreamImpl:

Collaboration diagram for trio::FileStreamImpl:

Public Member Functions
	FileStreamImpl (const char *path_, AccessMode accessMode_, OpenMode openMode_, MemoryResource *memRes_)
void	open () override
	Open access to the stream. More...
void	close () override
	Close access to the stream. More...
std::uint64_t	tell () override
	Get the current position in the stream. More...
void	seek (std::uint64_t position) override
	Set the current position in the stream. More...
std::uint64_t	size () override
	Obtain size of stream in bytes. More...
std::size_t	read (char *destination, std::size_t size) override
	Read bytes from stream into the given buffer. More...
std::size_t	read (Writable *destination, std::size_t size) override
	Read bytes from this stream into the given stream. More...
std::size_t	write (const char *source, std::size_t size) override
	Writes bytes from the given buffer to the stream. More...
std::size_t	write (Readable *source, std::size_t size) override
	Writes bytes from the given stream to this stream. More...
MemoryResource *	getMemoryResource ()
Public Member Functions inherited from trio::FileStream
	FileStream ()=default
	~FileStream () override
	FileStream (const FileStream &)=delete
FileStream &	operator= (const FileStream &)=delete
	FileStream (FileStream &&)=default
FileStream &	operator= (FileStream &&)=default
Public Member Functions inherited from trio::BoundedIOStream
virtual	~BoundedIOStream ()
virtual void	open ()=0
	Open access to the stream. More...
virtual void	close ()=0
	Close access to the stream. More...
virtual std::size_t	read (char *destination, std::size_t size)=0
	Read bytes from stream into the given buffer. More...
virtual std::size_t	read (Writable *destination, std::size_t size)=0
	Read bytes from this stream into the given stream. More...
virtual std::size_t	write (const char *source, std::size_t size)=0
	Writes bytes from the given buffer to the stream. More...
virtual std::size_t	write (Readable *source, std::size_t size)=0
	Writes bytes from the given stream to this stream. More...
virtual std::uint64_t	tell ()=0
	Get the current position in the stream. More...
virtual void	seek (std::uint64_t position)=0
	Set the current position in the stream. More...
virtual std::uint64_t	size ()=0
	Obtain size of stream in bytes. More...

Private Attributes
std::fstream	file
NativeString	filePath
AccessMode	fileAccessMode
OpenMode	fileOpenMode
std::uint64_t	fileSize
MemoryResource *	memRes
StreamStatus	status

Additional Inherited Members
Public Types inherited from trio::BoundedIOStream
using	AccessMode = trio::AccessMode
using	OpenMode = trio::OpenMode
Static Public Member Functions inherited from trio::FileStream
static FileStream *	create (const char *path, AccessMode accessMode, OpenMode openMode, MemoryResource *memRes=nullptr)
	Factory method for creation of a FileStream instance. More...
static void	destroy (FileStream *instance)
	Method for freeing a FileStream instance. More...
Static Public Attributes inherited from trio::BoundedIOStream
static const sc::StatusCode	OpenError {100, "Error opening file"}
static const sc::StatusCode	ReadError {101, "Error reading file"}
static const sc::StatusCode	WriteError {102, "Error writing file"}
static const sc::StatusCode	AlreadyOpenError {103, "File already open"}
static const sc::StatusCode	SeekError {104, "Error seeking file"}
Protected Member Functions inherited from trio::Controllable
virtual	~Controllable ()
Protected Member Functions inherited from trio::Openable
virtual	~Openable ()
Protected Member Functions inherited from trio::Closeable
virtual	~Closeable ()
Protected Member Functions inherited from trio::Readable
virtual	~Readable ()
Protected Member Functions inherited from trio::Writable
virtual	~Writable ()
Protected Member Functions inherited from trio::Seekable
virtual	~Seekable ()
Protected Member Functions inherited from trio::Bounded
virtual	~Bounded ()

Constructor & Destructor Documentation

FileStreamImpl()

trio::FileStreamImpl::FileStreamImpl	(	const char *	path_,
		AccessMode	accessMode_,
		OpenMode	openMode_,
		MemoryResource *	memRes_
	)

                                                                                                                     :
    filePath{NativeStringConverter::from(path_, memRes_)},
    fileAccessMode{accessMode_},
    fileOpenMode{openMode_},
    fileSize{getFileSizeStd(filePath.c_str())},
    memRes{memRes_} {
}

Member Function Documentation

close()

void trio::FileStreamImpl::close ( )

overridevirtual

Close access to the stream.

Implements trio::Closeable.

                           {
    file.close();
}

References file.

getMemoryResource()

MemoryResource * trio::FileStreamImpl::getMemoryResource

(

)

                                                  {
    return memRes;
}

References memRes.

open()

void trio::FileStreamImpl::open ( )

overridevirtual

Open access to the stream.

Implements trio::Openable.

                          {
    status->reset();
    if (file.is_open()) {
        status->set(AlreadyOpenError, filePath.c_str());
        return;
    }
 
    std::ios_base::openmode flags{};
    flags |= (contains(fileAccessMode, AccessMode::Read) ? std::ios_base::in : flags);
    flags |= (contains(fileAccessMode, AccessMode::Write) ? std::ios_base::out : flags);
    flags |= (contains(fileOpenMode, OpenMode::Binary) ? std::ios_base::binary : flags);
    flags |= std::ios_base::ate;
 
    if (fileAccessMode == AccessMode::ReadWrite) {
        ensureFileExistsStd(filePath.c_str());
    }
 
    file.open(filePath.c_str(), flags);
    if (!file.good()) {
        status->set(OpenError, filePath.c_str());
        return;
    }
    fileSize = static_cast<std::uint64_t>(file.tellg());
    seek(0ul);
}

References trio::BoundedIOStream::AlreadyOpenError, trio::Binary, trio::contains(), trio::anonymous_namespace{FileStreamImpl.cpp}::ensureFileExistsStd(), file, fileAccessMode, fileOpenMode, filePath, fileSize, trio::BoundedIOStream::OpenError, trio::Read, trio::ReadWrite, sc::StatusProvider::reset(), seek(), sc::StatusProvider::set(), status, and trio::Write.

read() [1/2]

std::size_t trio::FileStreamImpl::read ( char *  destination, std::size_t  size  )

overridevirtual

Read bytes from stream into the given buffer.

Parameters

destination	Destination buffer into which the data is going to be read from the stream.
size	Number of bytes to read from stream.

Returns

Number of bytes read.

Implements trio::Readable.

                                                                {
    if ((destination == nullptr) || file.fail() || !file.is_open() || !contains(fileAccessMode, AccessMode::Read)) {
        status->set(ReadError, filePath.c_str());
        return 0ul;
    }
 
    file.read(destination, static_cast<std::streamsize>(size));
    if (!file.good() && !file.eof()) {
        status->set(ReadError, filePath.c_str());
    }
 
    const auto bytesRead = file.gcount();
    return (bytesRead > 0 ? static_cast<std::size_t>(bytesRead) : 0ul);
}

References trio::contains(), file, fileAccessMode, filePath, trio::Read, trio::BoundedIOStream::ReadError, sc::StatusProvider::set(), size(), and status.

read() [2/2]

std::size_t trio::FileStreamImpl::read ( Writable *  destination, std::size_t  size  )

overridevirtual

Read bytes from this stream into the given stream.

Parameters

destination	Destination stream into which the data is going to be read from this stream.
size	Number of bytes to read from stream.

Returns

Number of bytes read.

Implements trio::Readable.

                                                                    {
    if ((destination == nullptr) || file.fail() || !file.is_open() || !contains(fileAccessMode, AccessMode::Read)) {
        status->set(ReadError, filePath.c_str());
        return 0ul;
    }
 
    char buffer[bufferSize];
    while (size > bufferSize) {
        file.read(buffer, static_cast<std::streamsize>(bufferSize));
        destination->write(buffer, bufferSize);
        size -= bufferSize;
    }
    file.read(buffer, static_cast<std::streamsize>(size));
    destination->write(buffer, size);
 
    if (!file.good() && !file.eof()) {
        status->set(ReadError, filePath.c_str());
    }
    const auto bytesRead = file.gcount();
    return (bytesRead > 0 ? static_cast<std::size_t>(bytesRead) : 0ul);
}

References trio::anonymous_namespace{FileStreamImpl.cpp}::bufferSize, trio::contains(), file, fileAccessMode, filePath, trio::Read, trio::BoundedIOStream::ReadError, sc::StatusProvider::set(), size(), status, and trio::Writable::write().

seek()

void trio::FileStreamImpl::seek ( std::uint64_t  position )

overridevirtual

Set the current position in the stream.

Parameters

position

Position in the stream relative to it's start, with 0 denoting the start position.

Implements trio::Seekable.

                                              {
    const bool seekable = (position == 0ul || position <= size()) && file.good();
    if (!seekable) {
        status->set(SeekError, filePath.c_str());
        return;
    }
 
    file.seekp(static_cast<std::streamoff>(position));
    if (!file.good()) {
        status->set(SeekError, filePath.c_str());
    }
}

References file, filePath, trio::BoundedIOStream::SeekError, sc::StatusProvider::set(), size(), and status.

Referenced by open().

size()

std::uint64_t trio::FileStreamImpl::size ( )

overridevirtual

Obtain size of stream in bytes.

Returns

Size in bytes.

Implements trio::Bounded.

                                 {
    return fileSize;
}

References fileSize.

Referenced by read(), seek(), and write().

tell()

std::uint64_t trio::FileStreamImpl::tell ( )

overridevirtual

Get the current position in the stream.

Returns

Position in the stream relative to it's start, with 0 denoting the start position.

Implements trio::Seekable.

                                 {
    return static_cast<std::uint64_t>(file.tellp());
}

References file.

write() [1/2]

std::size_t trio::FileStreamImpl::write ( const char *  source, std::size_t  size  )

overridevirtual

Writes bytes from the given buffer to the stream.

Parameters

source	Source buffer from which the data is going to be written to the stream.
size	Number of bytes to write to the stream.

Returns

Number of bytes written.

Implements trio::Writable.

                                                                  {
    if ((source == nullptr) || file.fail() || !file.is_open() || !contains(fileAccessMode, AccessMode::Write)) {
        status->set(WriteError, filePath.c_str());
        return 0ul;
    }
 
    const auto preWritePos = file.tellp();
    file.write(source, static_cast<std::streamsize>(size));
    const auto postWritePos = file.tellp();
 
    if (!file.good()) {
        status->set(WriteError, filePath.c_str());
    } else {
        fileSize = std::max(static_cast<std::uint64_t>(postWritePos), fileSize);
    }
 
    return (postWritePos > preWritePos ? static_cast<std::size_t>(postWritePos - preWritePos) : 0ul);
}

References trio::contains(), file, fileAccessMode, filePath, fileSize, sc::StatusProvider::set(), size(), status, trio::Write, and trio::BoundedIOStream::WriteError.

write() [2/2]

std::size_t trio::FileStreamImpl::write ( Readable *  source, std::size_t  size  )

overridevirtual

Writes bytes from the given stream to this stream.

Parameters

source	Source stream from which the data is going to be written into this stream.
size	Number of bytes to write to the stream.

Returns

Number of bytes written.

Implements trio::Writable.

                                                                {
    if ((source == nullptr) || file.fail() || !file.is_open() || !contains(fileAccessMode, AccessMode::Write)) {
        status->set(WriteError, filePath.c_str());
        return 0ul;
    }
 
    const auto preWritePos = file.tellp();
 
    char buffer[bufferSize];
    while (size > bufferSize) {
        source->read(buffer, bufferSize);
        file.write(buffer, static_cast<std::streamsize>(bufferSize));
        size -= bufferSize;
    }
    source->read(buffer, size);
    file.write(buffer, static_cast<std::streamsize>(size));
 
    const auto postWritePos = file.tellp();
 
    if (!file.good()) {
        status->set(WriteError, filePath.c_str());
    } else {
        fileSize = std::max(static_cast<std::uint64_t>(postWritePos), fileSize);
    }
 
    return (postWritePos > preWritePos ? static_cast<std::size_t>(postWritePos - preWritePos) : 0ul);
}

References trio::anonymous_namespace{FileStreamImpl.cpp}::bufferSize, trio::contains(), file, fileAccessMode, filePath, fileSize, trio::Readable::read(), sc::StatusProvider::set(), size(), status, trio::Write, and trio::BoundedIOStream::WriteError.

Member Data Documentation

file

std::fstream trio::FileStreamImpl::file

private

Referenced by close(), open(), read(), seek(), tell(), and write().

fileAccessMode

AccessMode trio::FileStreamImpl::fileAccessMode

private

Referenced by open(), read(), and write().

fileOpenMode

OpenMode trio::FileStreamImpl::fileOpenMode

private

Referenced by open().

filePath

NativeString trio::FileStreamImpl::filePath

private

Referenced by open(), read(), seek(), and write().

fileSize

std::uint64_t trio::FileStreamImpl::fileSize

private

Referenced by open(), size(), and write().

memRes

MemoryResource* trio::FileStreamImpl::memRes

private

Referenced by getMemoryResource().

status

StreamStatus trio::FileStreamImpl::status

private

Referenced by open(), read(), seek(), and write().

---

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

• FileStreamImpl.h
• FileStreamImpl.cpp