88 lines
1.6 KiB
C++
88 lines
1.6 KiB
C++
#pragma once
|
|
|
|
#include <sp/common/DataBuffer.h>
|
|
#include <sp/common/Templates.h>
|
|
|
|
namespace sp {
|
|
|
|
template <typename ValueType>
|
|
class Field {
|
|
public:
|
|
// Provide an access to the stored value
|
|
ValueType& GetValue() {
|
|
return m_Value;
|
|
}
|
|
const ValueType& GetValue() const {
|
|
return m_Value;
|
|
}
|
|
|
|
// Read (deserialise) and update internal value
|
|
void Read(DataBuffer& buffer) {
|
|
buffer >> m_Value;
|
|
}
|
|
|
|
// Write (serialise) internal value
|
|
void Write(DataBuffer& buffer) const {
|
|
buffer << m_Value;
|
|
}
|
|
|
|
Field& operator=(const ValueType& value) {
|
|
m_Value = value;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
ValueType m_Value;
|
|
};
|
|
|
|
// Functor used to read all tuple values
|
|
class FieldReader {
|
|
public:
|
|
FieldReader(DataBuffer& buffer) : m_Buffer(buffer) {}
|
|
|
|
template <typename TField>
|
|
void operator()(TField& field) {
|
|
field.Read(m_Buffer);
|
|
}
|
|
|
|
private:
|
|
DataBuffer& m_Buffer;
|
|
};
|
|
|
|
// Functor used to write all tuple values
|
|
class FieldWriter {
|
|
public:
|
|
FieldWriter(DataBuffer& buffer) : m_Buffer(buffer) {}
|
|
|
|
template <typename TField>
|
|
void operator()(TField& field) {
|
|
field.Write(m_Buffer);
|
|
}
|
|
|
|
private:
|
|
DataBuffer& m_Buffer;
|
|
};
|
|
|
|
namespace details {
|
|
|
|
template <typename... TFields>
|
|
struct FieldsBuilder {};
|
|
|
|
template <>
|
|
struct FieldsBuilder<> {
|
|
using Type = std::tuple<>;
|
|
};
|
|
|
|
template <typename... TFields>
|
|
struct FieldsBuilder<std::tuple<TFields...>> {
|
|
using Type = typename FieldsBuilder<TFields...>::Type;
|
|
};
|
|
|
|
template <typename TField, typename... TFields>
|
|
struct FieldsBuilder<TField, TFields...> {
|
|
using Type = sp::tuple_cat_t<std::tuple<Field<TField>>, typename FieldsBuilder<TFields...>::Type>;
|
|
};
|
|
} // namespace details
|
|
|
|
} // namespace sp
|