terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder > Class Template Reference

#include <OutputArchive.h>

Inheritance diagram for terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >:

Collaboration diagram for terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >:

Public Types
using	SizeType = TSize
using	OffsetType = TOffset

Public Member Functions
	ExtendableBinaryOutputArchive (TExtender *extender, TStream *stream_)
bool	isOk ()
void	sync ()
void	label (const char *)
Public Member Functions inherited from terse::Archive< TExtender >
	Archive (TExtender *impl_)
bool	isOk ()
void	sync ()
void	label (const char *value)
void	operator() (Args &&... args)
TExtender &	operator<< (TSerializable &source)
TExtender &	operator>> (TSerializable &dest)
void *	getUserData () const
void	setUserData (void *data)

Static Public Member Functions
static constexpr Endianness	endianness ()

Protected Member Functions
template<typename T >
void	process (Transparent< T > &&source)
void	process (Anchor< OffsetType > &source)
void	process (ArchiveOffset< OffsetType > &source)
void	process (typename ArchiveOffset< OffsetType >::Proxy &source)
void	process (typename ArchiveOffset< OffsetType >::Proxy &&source)
void	process (ArchiveSize< SizeType, OffsetType > &source)
void	process (typename ArchiveSize< SizeType, OffsetType >::Proxy &source)
void	process (typename ArchiveSize< SizeType, OffsetType >::Proxy &&source)
template<typename T , typename ... Args>
void	process (const Blob< T, Args... > &source)
template<typename T >
std::enable_if< traits::has_save_member< T >::value, void >::type	process (const T &source)
template<typename T >
std::enable_if< traits::has_serialize_member< T >::value, void >::type	process (const T &source)
template<typename T >
std::enable_if< traits::has_save_function< T >::value, void >::type	process (const T &source)
template<typename T >
std::enable_if< traits::has_serialize_function< T >::value, void >::type	process (const T &source)
template<typename T >
std::enable_if<!traits::has_save_member< T >::value &&!traits::has_serialize_member< T >::value &&!traits::has_save_function< T >::value &&!traits::has_serialize_function< T >::value, void >::type	process (const T &source)
template<typename T , std::size_t N>
void	process (const std::array< T, N > &source)
template<typename T , typename ... Args>
void	process (const std::vector< T, Args... > &source)
template<typename T , typename ... Args>
void	process (const DynArray< T, Args... > &source)
template<typename T , typename ... Args>
void	process (const std::basic_string< T, Args... > &source)
template<typename K , typename V >
void	process (const std::pair< K, V > &source)
template<typename K , typename V >
void	process (const std::tuple< K, V > &source)
void	processSize (std::size_t size)
template<class TContainer >
std::enable_if<!traits::is_batchable< TContainer >::value >::type	processElements (const TContainer &source)
template<class TContainer >
std::enable_if< traits::is_batchable< TContainer >::value &&traits::has_wide_elements< TContainer >::value >::type	processElements (const TContainer &source)
template<class TContainer >
std::enable_if< traits::is_batchable< TContainer >::value &&!traits::has_wide_elements< TContainer >::value >::type	processElements (const TContainer &source)
Protected Member Functions inherited from terse::Archive< TExtender >
void	dispatch (Head &&head)
void	dispatch (Head &&head, Tail &&... tail)

Private Types
using	BaseArchive = Archive< TExtender >

Private Attributes
TStream *	stream

Member Typedef Documentation

BaseArchive

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

using terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::BaseArchive = Archive<TExtender>

private

OffsetType

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

using terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::OffsetType = TOffset

SizeType

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

using terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::SizeType = TSize

Constructor & Destructor Documentation

ExtendableBinaryOutputArchive()

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::ExtendableBinaryOutputArchive ( TExtender *  extender, TStream *  stream_  )

inline

                                                                             : BaseArchive{extender}, stream{stream_} {
        }

Member Function Documentation

endianness()

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

static constexpr Endianness terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::endianness ( )

inlinestaticconstexpr

                                                 {
            return EByteOrder;
        }

isOk()

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

bool terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::isOk ( )

inline

                    {
            return true;
        }

label()

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::label ( const char *  )

inline

                                   {
        }

process() [1/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( Anchor< OffsetType > &  source )

inlineprotected

                                                 {
            source.value = static_cast<OffsetType>(stream->tell());
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream, and terse::Anchor< TOffset >::value.

process() [2/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( ArchiveOffset< OffsetType > &  source )

inlineprotected

                                                        {
            // Record the position where the offset is going to be written so it can be seeked to later when
            // its proxy is found
            #if !defined(__clang__) && defined(__GNUC__)
                #pragma GCC diagnostic push
                #pragma GCC diagnostic ignored "-Wuseless-cast"
            #endif
            source.position = static_cast<decltype(source.position)>(stream->tell());
            #if !defined(__clang__) && defined(__GNUC__)
                #pragma GCC diagnostic pop
            #endif
            // Since the actual offset value is not yet known at the time when its declaration is encountered,
            // fill its place with zeros as a placeholder, and it will be later populated when its associated
            // proxy is found
            process(typename ArchiveOffset<OffsetType>::ValueType{});
        }

References terse::ArchiveOffset< TOffset >::position, terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream.

process() [3/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( ArchiveSize< SizeType, OffsetType > &  source )

inlineprotected

                                                                {
            // Record the position where the size is going to be written so it can be seeked to later when
            // its proxy is found
            #if !defined(__clang__) && defined(__GNUC__)
                #pragma GCC diagnostic push
                #pragma GCC diagnostic ignored "-Wuseless-cast"
            #endif
            source.position = static_cast<decltype(source.position)>(stream->tell());
            #if !defined(__clang__) && defined(__GNUC__)
                #pragma GCC diagnostic pop
            #endif
            // Since the actual size value is not yet known at the time when it's declaration is encountered,
            // fill it's place with zeros as a placeholder, and it will be later populated when it's associated
            // proxy is found
            process(typename ArchiveSize<SizeType, OffsetType>::ValueType{});
        }

References terse::ArchiveSize< TSize, TOffset >::position, terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream.

process() [4/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T , typename ... Args>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const Blob< T, Args... > &  source )

inlineprotected

                                                     {
            using ValueType = typename Blob<T, Args...>::value_type;
            if (source.size() != 0ul) {
                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                stream->write(reinterpret_cast<const char*>(source.data()), source.size() * sizeof(ValueType));
            }
        }

References terse::Blob< T, TAllocator >::data(), terse::Blob< T, TAllocator >::size(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream.

process() [5/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T , typename ... Args>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const DynArray< T, Args... > &  source )

inlineprotected

                                                         {
            processSize(source.size());
            processElements(source);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements(), terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processSize(), and terse::DynArray< T, TAllocator >::size().

process() [6/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T , std::size_t N>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const std::array< T, N > &  source )

inlineprotected

                                                   {
            processElements(source);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements().

process() [7/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T , typename ... Args>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const std::basic_string< T, Args... > &  source )

inlineprotected

                                                                {
            processSize(source.size());
            processElements(source);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processSize().

process() [8/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename K , typename V >

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const std::pair< K, V > &  source )

inlineprotected

                                                  {
            BaseArchive::dispatch(source.first);
            BaseArchive::dispatch(source.second);
        }

References terse::Archive< TExtender >::dispatch().

process() [9/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename K , typename V >

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const std::tuple< K, V > &  source )

inlineprotected

                                                   {
            BaseArchive::dispatch(std::get<0>(source));
            BaseArchive::dispatch(std::get<1>(source));
        }

References terse::Archive< TExtender >::dispatch().

process() [10/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T , typename ... Args>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const std::vector< T, Args... > &  source )

inlineprotected

                                                          {
            processSize(source.size());
            processElements(source);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processSize().

process() [11/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T >

std::enable_if< traits::has_save_member< T >::value, void >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const T &  source )

inlineprotected

                                                                   {
            const_cast<T&>(source).save(*static_cast<TExtender*>(this));
        }

process() [12/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T >

std::enable_if< traits::has_serialize_member< T >::value, void >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const T &  source )

inlineprotected

                                                                   {
            const_cast<T&>(source).serialize(*static_cast<TExtender*>(this));
        }

process() [13/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T >

std::enable_if< traits::has_save_function< T >::value, void >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const T &  source )

inlineprotected

                                                                   {
            save(*static_cast<TExtender*>(this), const_cast<T&>(source));
        }

process() [14/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T >

std::enable_if< traits::has_serialize_function< T >::value, void >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const T &  source )

inlineprotected

                                                                   {
            serialize(*static_cast<TExtender*>(this), const_cast<T&>(source));
        }

process() [15/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T >

std::enable_if<!traits::has_save_member< T >::value &&!traits::has_serialize_member< T >::value &&!traits::has_save_function< T >::value &&!traits::has_serialize_function< T >::value, void >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( const T &  source )

inlineprotected

                                                                   {
            T swapped;
            std::memcpy(&swapped, &source, sizeof(T));
            SwapTo<EByteOrder>::swap(swapped);
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
            stream->write(reinterpret_cast<char*>(&swapped), sizeof(T));
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream.

process() [16/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<typename T >

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( Transparent< T > &&  source )

inlineprotected

                                              {
            process(source.data);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process().

Referenced by terse::BinaryOutputArchive< TStream, TSize, TOffset, EByteOrder >::process(), terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processSize().

process() [17/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( typename ArchiveOffset< OffsetType >::Proxy &&  source )

inlineprotected

                                                                       {
            process(source);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process().

process() [18/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( typename ArchiveOffset< OffsetType >::Proxy &  source )

inlineprotected

                                                                      {
            // The current position of the stream needs to be written to the position where the associated
            // `ArchiveOffset` is found.
            auto current = stream->tell();
            assert(current <= std::numeric_limits<OffsetType>::max());
            source.target->value = static_cast<OffsetType>(current);
            // Seek to the actual position of the offset marker and write the stream's above captured position there
            stream->seek(source.target->position);
            process(static_cast<OffsetType>(current));
            // Return to the earlier captured stream position so processing can safely resume from there
            stream->seek(current);
        }

References terse::ArchiveOffset< TOffset >::position, terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream, terse::ArchiveOffset< TOffset >::Proxy::target, and terse::ArchiveOffset< TOffset >::value.

process() [19/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( typename ArchiveSize< SizeType, OffsetType >::Proxy &&  source )

inlineprotected

                                                                               {
            process(source);
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process().

process() [20/20]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process ( typename ArchiveSize< SizeType, OffsetType >::Proxy &  source )

inlineprotected

                                                                              {
            // The current position of the stream minus the base offset needs to be written to the position
            // where the associated `ArchiveSize` is found.
            const auto current = stream->tell();
            assert(source.base != nullptr);
            assert(source.base->value <= current);
            auto size = current - source.base->value;
            assert(size <= std::numeric_limits<SizeType>::max());
            source.target->value = static_cast<SizeType>(size);
            // Seek to the actual position of the size marker and write the above calculated size
            stream->seek(source.target->position);
            process(static_cast<SizeType>(size));
            // Return to the earlier captured stream position so processing can safely resume from there
            stream->seek(current);
        }

References terse::ArchiveSize< TSize, TOffset >::Proxy::base, terse::ArchiveSize< TSize, TOffset >::position, terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream, terse::ArchiveSize< TSize, TOffset >::Proxy::target, and terse::ArchiveSize< TSize, TOffset >::value.

processElements() [1/3]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<class TContainer >

std::enable_if<!traits::is_batchable< TContainer >::value >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements ( const TContainer &  source )

inlineprotected

                                                  {
            for (const auto& element : source) {
                BaseArchive::dispatch(element);
            }
        }

References terse::Archive< TExtender >::dispatch().

Referenced by terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process().

processElements() [2/3]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<class TContainer >

std::enable_if< traits::is_batchable< TContainer >::value &&traits::has_wide_elements< TContainer >::value >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements ( const TContainer &  source )

inlineprotected

                                                  {
            for (const auto& element : source) {
                BaseArchive::dispatch(element);
            }
        }

References terse::Archive< TExtender >::dispatch().

processElements() [3/3]

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

template<class TContainer >

std::enable_if< traits::is_batchable< TContainer >::value &&!traits::has_wide_elements< TContainer >::value >::type terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements ( const TContainer &  source )

inlineprotected

                                                  {
            using ValueType = typename TContainer::value_type;
            const auto size = source.size();
            if (size != 0ul) {
                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                stream->write(reinterpret_cast<const char*>(&source[0]), size * sizeof(ValueType));
            }
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream.

processSize()

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processSize ( std::size_t  size )

inlineprotected

                                         {
            assert(size <= std::numeric_limits<SizeType>::max());
            process(static_cast<SizeType>(size));
        }

References terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process().

Referenced by terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process().

sync()

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

void terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::sync ( )

inline

                    {
        }

Member Data Documentation

stream

template<class TExtender , class TStream , typename TSize , typename TOffset , Endianness EByteOrder>

TStream* terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::stream

private

Referenced by terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), and terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::processElements().

---

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

• binary/OutputArchive.h