trio Namespace Reference

Namespaces
namespace	anonymous_namespace{FileStreamImpl.cpp}
namespace	anonymous_namespace{MemoryStreamImpl.cpp}

Classes
class	Bounded
class	BoundedIOStream
class	Buffered
class	Closeable
class	Controllable
class	FileStream
	Standard file stream. More...
class	FileStreamImpl
class	MemoryMappedFileStream
	Memory mapped file stream. More...
class	MemoryMappedFileStreamFallback
class	MemoryStream
	In-memory stream. More...
class	MemoryStreamImpl
class	Openable
class	Readable
class	Resizable
class	Seekable
class	StreamScope
class	StreamStatus
struct	StringConverter
struct	StringConverter< char >
struct	StringConverter< wchar_t >
class	Writable

Typedefs
using	MemoryMappedFileStreamImpl = MemoryMappedFileStreamFallback
using	NativeCharacter = char
using	NativeString = pma::String< NativeCharacter >
using	NativeStringConverter = StringConverter< NativeCharacter >

Enumerations
enum class	AccessMode { Read = 1 , Write = 2 , ReadWrite = 3 }
enum class	OpenMode { Binary = 4 , Text = 8 }

Functions
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator& (TEnum lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator| (TEnum lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator^ (TEnum lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator~ (TEnum value)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator&= (TEnum &lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator|= (TEnum &lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator^= (TEnum &lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, bool >::type	contains (TEnum lhs, TEnum rhs)

Typedef Documentation

MemoryMappedFileStreamImpl

using trio::MemoryMappedFileStreamImpl = typedef MemoryMappedFileStreamFallback

NativeCharacter

using trio::NativeCharacter = typedef char

NativeString

using trio::NativeString = typedef pma::String<NativeCharacter>

NativeStringConverter

using trio::NativeStringConverter = typedef StringConverter<NativeCharacter>

Enumeration Type Documentation

AccessMode

enum class trio::AccessMode

strong

Enumerator
Read
Write
ReadWrite

                      {
    Read = 1,
    Write = 2,
    ReadWrite = 3
};

OpenMode

enum class trio::OpenMode

strong

Enumerator
Binary
Text

                    {
    Binary = 4,
    Text = 8
};

Function Documentation

contains()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, bool >::type trio::contains	(	TEnum	lhs,
		TEnum	rhs
	)

                               {
    return (lhs & rhs) == rhs;
}

Referenced by trio::FileStreamImpl::open(), trio::FileStreamImpl::read(), and trio::FileStreamImpl::write().

operator&()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator&	(	TEnum	lhs,
		TEnum	rhs
	)

                                {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(static_cast<Underlying>(lhs) & static_cast<Underlying>(rhs));
}

operator&=()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator&=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs & rhs);
}

operator^()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator^	(	TEnum	lhs,
		TEnum	rhs
	)

                                {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(static_cast<Underlying>(lhs) ^ static_cast<Underlying>(rhs));
}

operator^=()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator^=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs ^ rhs);
}

operator|()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator|	(	TEnum	lhs,
		TEnum	rhs
	)

                                {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(static_cast<Underlying>(lhs) | static_cast<Underlying>(rhs));
}

operator|=()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator|=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs | rhs);
}

operator~()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type trio::operator~

(

TEnum

value

)

                       {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(~static_cast<Underlying>(value));
}