Improvement of binary serializer (f6f98f2a) · Commits · Tomáš Jakubec / GTMesh

src/GTMesh/BinarySerializer/BinarySerializer.h

+56 −7

Original line number	Diff line number	Diff line
		@@ -28,32 +28,74 @@ public:
		return data;
		}

		template<typename T, typename ... Rest>
		void write(const T& data, const Rest&... additionalData) {
		write(data)
		write(additionalData...);
		}

		template<typename T>
		void maddNext(const T& data) {
		void write(const T& data) {
		addNext(mData, data);
		}

		template <typename T>
		void mreadNext(T& data) {
		BinarySerializer& operator<<(const T& value) {
		this->write(value);
		return *this;
		}

		template <typename T, typename ... Rest>
		void read(T& data, Rest&... additionalData) {
		read(data);
		read(additionalData...);
		}

		template <typename T>
		void read(T& data) {
		resetIteratorIfNotValid();
		readNext(mDataIterator, data);
		}

		template <typename T>
		T mreadNext() {
		T read() {
		return readNext<T>(mDataIterator);
		}

		template <typename T>
		BinarySerializer& operator>>(T& value) {
		this->read(value);
		return *this;
		}

		void resetIterator() {
		mDataIterator = mData.cbegin();
		}
		//private:

		bool isIteratorValid() {
		return mData.begin() <= mDataIterator && mData.end() > mDataIterator;
		}

		void resetIteratorIfNotValid() {
		if (!isIteratorValid()) {
		resetIterator();
		}
		}

		void clear() {
		mData.clear();
		mDataIterator = {};
		}
		private:
		ByteContainer mData;
		ByteContainerIterator mDataIterator;
		};

		#include "Serializers/SerializeCustom.h"
		#include "Serializers/SerializeSimple.h"
		#include "Serializers/SerializeTraitedClass.h"
		#include "Serializers/SerializeIterable.h"
		#include "Serializers/SerializeIndexable.h"
		#include "Serializers/SerializeTuple.h"
		#include <GTMesh/Utils/ClassSelector.h>

		@@ -79,7 +121,7 @@ struct IsDeserializableBy<
		VarType,
		Serializer,
		decltype(Serializer::deserialize(std::declval<std::vector<unsigned char>::const_iterator &>(),
		std::declval<const VarType &>()))> : public std::true_type
		std::declval<VarType &>()))> : public std::true_type
		{};

		} // Impl namespace
		@@ -94,8 +136,13 @@ using SelectSerializer = ClassSelector<VarType, IsSerializableBy, Serializers...
		template<typename T>
		void BinarySerializer::addNext(std::vector<BinarySerializer::Byte> &binaryDataContainer, const T &data)
		{
		SelectSerializer<T, SerializeCustom, SerializeSimple, SerializeIterable, SerializeTuple>::
		SelectedClass::serialize(binaryDataContainer, data);
		SelectSerializer<T,
		SerializeCustom,
		SerializeSimple,
		SerializeTraitedClass,
		SerializeIterable,
		SerializeIndexable,
		SerializeTuple>::SelectedClass::serialize(binaryDataContainer, data);
		}

		template<typename VarType, typename Serializer>
		@@ -111,9 +158,11 @@ void BinarySerializer::readNext(std::vector<Byte>::const_iterator& binaryDataIte
		SelectDeserializer<T,
		SerializeCustom,
		SerializeSimple,
		SerializeTraitedClass,
		DeserializeAsociativeMap,
		DeserializeAsociativeSet,
		SerializeIterable,
		SerializeIndexable,
		SerializeTuple>::SelectedClass::deserialize(binaryDataIterator, data);
		}

src/GTMesh/BinarySerializer/Serializers/SerializeCustom.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -10,7 +10,7 @@ struct SerializeCustom {


		template <typename T>
		using IsBitviseDeserializable = Impl::void_t<decltype(BinaryDeserialize(std::declval<BinarySerializer::ByteContainerIterator&>(), std::declval<const T&>()))>;
		using IsBitviseDeserializable = Impl::void_t<decltype(BinaryDeserialize(std::declval<BinarySerializer::ByteContainerIterator&>(), std::declval<T&>()))>;


		template <typename T>

src/GTMesh/BinarySerializer/Serializers/SerializeIndexable.h

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		#ifndef SERIALIZEINDEXABLE_H
		#define SERIALIZEINDEXABLE_H
		#include <GTMesh/Traits/CustomTypeTraits.h>
		#include "../BinarySerializer.h"
		struct SerializeIndexable {
		template <typename T, typename ..., std::enable_if_t<IsIndexable<T>::value, bool> = true>
		static void serialize(std::vector<unsigned char>& dataContainer, const T& data){
		using size_type = decltype(data.size());

		BinarySerializer::addNext(dataContainer, data.size());
		size_type size = data.size();

		for (size_type i = 0; i < size; i++) {
		BinarySerializer::addNext(dataContainer, data[i]);
		}
		}



		template <typename T, typename ..., std::enable_if_t<IsIndexable<T>::value, bool> = true>
		static void deserialize(std::vector<unsigned char>::const_iterator& dataIterator, T& data){
		using size_type = decltype(data.size());
		size_type size = BinarySerializer::readNext<decltype(data.size())>(dataIterator);

		if (data.size() != size) {
		data.resize(size);
		}

		for (size_type i = 0; i < size; i++) {
		BinarySerializer::readNext(dataIterator, data[i]);
		}
		}

		};
		#endif // SERIALIZEINDEXABLE_H

src/GTMesh/BinarySerializer/Serializers/SerializeTraitedClass.h

0 → 100644

+52 −0

Original line number	Diff line number	Diff line
		#ifndef SERIALIZETRAITEDCLASS_H
		#define SERIALIZETRAITEDCLASS_H
		#include <GTMesh/Utils/ConstexprFor.h>
		#include <GTMesh/Traits/Traits.h>
		#include "../BinarySerializer.h"


		struct SerializeTraitedClass{
		protected:
		// Helper functions serializing the instance of traited class
		struct TraitedClassBinarySerializer
		{
		template<size_t Index, typename TraitedType, typename TraitsType>
		static void exec(BinarySerializer::ByteContainer &container,
		const TraitedType &var,
		const TraitsType &traits)
		{
		BinarySerializer::addNext(container, traits.template getValue<Index>(var));
		}
		};

		struct TraitedClassBinaryDeserializer
		{
		template<size_t Index, typename TraitedType, typename TraitsType>
		static void exec(BinarySerializer::ByteContainerIterator &it,
		TraitedType &var,
		const TraitsType &traits)
		{
		BinarySerializer::readNext(it, traits.template getAttr<Index>(var));
		}
		};

		public:
		template<typename T,
		typename...,
		std::enable_if_t<HasDefaultArithmeticTraits<T>::value, bool> = true>
		static void serialize(BinarySerializer::ByteContainer &container, const T &var)
		{
		constexprFor<TraitedClassBinarySerializer, DefaultArithmeticTraits<T>::size()>(
		container, var, DefaultArithmeticTraits<T>::getTraits());
		}

		template<typename T,
		typename...,
		std::enable_if_t<HasDefaultArithmeticTraits<T>::value, bool> = true>
		static void deserialize(BinarySerializer::ByteContainerIterator &it, T &var)
		{
		constexprFor<TraitedClassBinaryDeserializer, DefaultArithmeticTraits<T>::size()>(
		it, var, DefaultArithmeticTraits<T>::getTraits());
		}
		};
		#endif // SERIALIZETRAITEDCLASS_H

src/GTMesh/Traits/MemberAccess/MemberAccess.h

+4 −2

Original line number	Diff line number	Diff line
		@@ -32,17 +32,19 @@ public:

		constexpr MemberAccess(MemberAccess<Class, ValueType Class::*, void> &&) = default;

		inline ValueType getValue(const Class c) const { return c->mReference; }
		inline const ValueType& getValue(const Class c) const { return c->mReference; }

		inline void setValue(Class c, const ValueType &val) const { c->mReference = val; }

		inline ValueType &getAttr(Class c) const { return c->mReference; }
		inline const ValueType &getAttr(const Class c) const { return c->mReference; }

		inline ValueType getValue(const Class &c) const { return c.*mReference; }
		inline const ValueType& getValue(const Class &c) const { return c.*mReference; }

		inline void setValue(Class &c, const ValueType &val) const { c.*mReference = val; }

		inline ValueType &getAttr(Class &c) const { return c.*mReference; }
		inline const ValueType &getAttr(const Class &c) const { return c.*mReference; }
		};

		// Experimental function traits approach