jeanlemotan
93 lines
2.6 KiB
C++
93 lines
2.6 KiB
C++
#pragma once
|
|
|
|
#include <tl/optional.h>
|
|
#include <tl/span.h>
|
|
#include "fs/Error.h"
|
|
#include "fs/Api.h"
|
|
|
|
namespace fs
|
|
{
|
|
|
|
class FS_API IStreamSink
|
|
{
|
|
public:
|
|
IStreamSink() = default;
|
|
virtual ~IStreamSink() = default;
|
|
|
|
IStreamSink(IStreamSink&&) = default;
|
|
IStreamSink& operator=(IStreamSink&&) = default;
|
|
|
|
//This will return the last generated error AND CLEAR IT AFTERWARDS.
|
|
virtual tl::optional<Error> getLastError() const = 0;
|
|
|
|
//writes size bytes from the buffer to the sink at the current cursor position.
|
|
//the sink size is increased if the sinks reaches the end
|
|
virtual size_t write(tl::span<const uint8_t> data) = 0;
|
|
|
|
//returns the size of the sink. Always >= tell
|
|
virtual uint64_t getSize() const = 0;
|
|
|
|
// The preferred buffer size for writes. Use this buffer size for optimal performance
|
|
// If zero, use whatever you want
|
|
virtual size_t getPreferredBufferSize() const = 0;
|
|
};
|
|
|
|
template<typename T, bool isEnum>
|
|
struct StreamSinkSerializationHelperWrite_Internal;
|
|
|
|
template<typename T>
|
|
struct StreamSinkSerializationHelperWrite_Internal<T, false>
|
|
{
|
|
static IStreamSink& write(IStreamSink& s, const T& val)
|
|
{
|
|
static_assert(std::is_standard_layout_v<T> && !std::is_pointer_v<T> && !std::is_array_v<T>, "You need a specialized write for T");
|
|
s.write({ reinterpret_cast<const uint8_t*>(&val), sizeof(T) });
|
|
return s;
|
|
}
|
|
|
|
static IStreamSink& write(IStreamSink& s, tl::span<const T> val)
|
|
{
|
|
const uint32_t count = static_cast<uint32_t>(val.size());
|
|
s.write({ reinterpret_cast<const uint8_t*>(&count), sizeof(count) });
|
|
for(const T& v : val)
|
|
s.write( { reinterpret_cast<const uint8_t*>(&v), sizeof(T) });
|
|
return s;
|
|
}
|
|
};
|
|
|
|
// specialization to read enums
|
|
template<typename EnumType>
|
|
struct StreamSinkSerializationHelperWrite_Internal<EnumType, true>
|
|
{
|
|
static IStreamSink& write(IStreamSink& s, const EnumType& val)
|
|
{
|
|
// first read into the temporary of the underlying type
|
|
using underlying_t = std::underlying_type_t<EnumType>;
|
|
underlying_t underlyingValue = static_cast<underlying_t>(val);
|
|
|
|
IStreamSink& ret = StreamSinkSerializationHelperWrite_Internal<underlying_t, false>::write(s, underlyingValue);
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct SimpleStreamSerializationHelperWrite : StreamSinkSerializationHelperWrite_Internal<T, std::is_enum_v<std::remove_reference_t<T>>>
|
|
{
|
|
};
|
|
|
|
template <typename T>
|
|
IStreamSink& operator<<(IStreamSink& s, const T& val)
|
|
{
|
|
return SimpleStreamSerializationHelperWrite<T>::write(s, val);
|
|
}
|
|
|
|
template <typename T>
|
|
IStreamSink& operator<<(IStreamSink& s, tl::span<const T> val)
|
|
{
|
|
return SimpleStreamSerializationHelperWrite<T>::write(s, val);
|
|
}
|
|
|
|
}
|
|
|
|
|