tomoto 0.1.4 → 0.2.0

data/vendor/tomotopy/src/Utils/Utils.hpp

@@ -10,25 +10,110 @@
 
 namespace tomoto
 {
-	template<typename T, typename... Args, 
-		typename std::enable_if<!std::is_array<T>::value, int>::type = 0>
-	std::unique_ptr<T> make_unique(Args&&... args)
-	{
-		return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-	}
-
-	template<typename T,
-		typename std::enable_if<std::is_array<T>::value, int>::type = 0>
-	std::unique_ptr<T> make_unique(size_t size)
-	{
-		return std::unique_ptr<T>(new typename std::remove_extent<T>::type [size]);
-	}
-
 	template<typename T>
 	constexpr T * as_mutable(const T * value) noexcept {
 		return const_cast<T *>(value);
 	}
 
+	template <typename T>
+	class PreventCopy : public T
+	{
+	public:
+		template <typename... Args>
+		PreventCopy(Args&&... args) :
+			T(std::forward<Args>(args)...)
+		{
+		}
+
+		PreventCopy(const PreventCopy& from)
+		{
+		}
+
+		PreventCopy(PreventCopy&& from) :
+			T(static_cast<T&&>(from))
+		{
+		}
+
+		PreventCopy& operator=(const T& from)
+		{
+			T::operator=(from);
+			return *this;
+		}
+
+		PreventCopy& operator=(T&& from)
+		{
+			T::operator=(std::move(from));
+			return *this;
+		}
+
+		PreventCopy& operator=(const PreventCopy& from)
+		{
+			return *this;
+		}
+
+		PreventCopy& operator=(PreventCopy&& from)
+		{
+			T::operator=(static_cast<T&&>(from));
+			return *this;
+		}
+	};
+
+	template <typename T, typename Delegator>
+	class DelegateCopy : public T
+	{
+	public:
+		template <typename... Args>
+		DelegateCopy(Args&&... args) :
+			T(std::forward<Args>(args)...)
+		{
+		}
+
+		DelegateCopy(const T& from) :
+			T(Delegator{}(from))
+		{
+		}
+
+		DelegateCopy(const DelegateCopy& from) :
+			T(Delegator{}(from))
+		{
+		}
+
+		DelegateCopy(T&& from) :
+			T(static_cast<T&&>(from))
+		{
+		}
+
+		DelegateCopy(DelegateCopy&& from) :
+			T(static_cast<T&&>(from))
+		{
+		}
+
+		DelegateCopy& operator=(const T& from)
+		{
+			T::operator=(from);
+			return *this;
+		}
+
+		DelegateCopy& operator=(T&& from)
+		{
+			T::operator=(std::move(from));
+			return *this;
+		}
+
+		DelegateCopy& operator=(const DelegateCopy& from)
+		{
+			T::operator=(Delegator{}(from));
+			return *this;
+		}
+
+		DelegateCopy& operator=(DelegateCopy&& from)
+		{
+			T::operator=(static_cast<T&&>(from));
+			return *this;
+		}
+	};
+
+
 	template<bool _lock>
 	class OptionalLock : public std::lock_guard<std::mutex>
 	{

data/vendor/tomotopy/src/Utils/exception.h

@@ -3,7 +3,7 @@
 #include "text.hpp"
 namespace tomoto
 {
-	namespace exception
+	namespace exc
 	{
 		class TrainingError : public std::runtime_error
 		{

data/vendor/tomotopy/src/Utils/math.h

@@ -155,30 +155,28 @@ namespace tomoto
 
 		// approximation : lgamma(z) ~= (z+2.5)ln(z+3) - z - 3 + 0.5 ln (2pi) + 1/12/(z + 3) - ln (z(z+1)(z+2))
 		template<class _T>
-		inline auto lgammaApprox(_T z) -> decltype((z + 2.5)* log(z + 3) - (z + 3) + 0.91893853 + 1. / 12. / (z + 3) - log(z * (z + 1) * (z + 2)))
+		inline auto lgammaApprox(_T z)
 		{
 			return (z + 2.5) * log(z + 3) - (z + 3) + 0.91893853 + 1. / 12. / (z + 3) - log(z * (z + 1) * (z + 2));
 		}
 
 		// calc lgamma(z + a) - lgamma(z)
 		template<class _T, class _U>
-		inline auto lgammaSubt(_T z, _U a) -> decltype((z + a + 1.5)* log(z + a + 2) - (z + 1.5) * log(z + 2) - a + (1. / (z + a + 2) - 1. / (z + 2)) / 12. - log(((z + a) * (z + a + 1)) / (z * (z + 1))))
+		inline auto lgammaSubt(_T z, _U a)
 		{
-			return (z + a + 1.5) * log(z + a + 2) - (z + 1.5) * log(z + 2) - a + (1. / (z + a + 2) - 1. / (z + 2)) / 12. - log(((z + a) * (z + a + 1)) / (z * (z + 1)));
+			return (z + a + 1.5) * log(z + a + 2) - (z + 1.5) * log(z + 2) - a + (1. / (z + a + 2) - 1. / (z + 2)) / 12. - log((z + a) / z * (z + a + 1) / (z + 1));
 		}
 
 		// approximation : digamma(z) ~= ln(z+4) - 1/2/(z+4) - 1/12/(z+4)^2 - 1/z - 1/(z+1) - 1/(z+2) - 1/(z+3)
 		template<class _T>
-		inline auto digammaApprox(_T z) -> decltype(log(z + 4) - 1. / 2. / (z + 4) - 1. / 12. / ((z + 4) * (z + 4)) - 1. / z - 1. / (z + 1) - 1. / (z + 2) - 1. / (z + 3))
+		inline auto digammaApprox(_T z)
 		{
 			return log(z + 4) - 1. / 2. / (z + 4) - 1. / 12. / ((z + 4) * (z + 4)) - 1. / z - 1. / (z + 1) - 1. / (z + 2) - 1. / (z + 3);
 		}
 
 		// calc digamma(z + a) - digamma(z)
 		template<class _T, class _U>
-		inline auto digammaSubt(_T z, _U a) -> decltype(log((z + a + 2) / (z + 2)) - (1 / (z + a + 2) - 1 / (z + 2)) / 2 - (1 / (z + a + 2) / (z + a + 2) - 1 / (z + 2) / (z + 2)) / 12
-			- 1. / (z + a) - 1. / (z + a + 1)
-			- 1. / z - 1. / (z + 1))
+		inline auto digammaSubt(_T z, _U a)
 		{
 			return log((z + a + 2) / (z + 2)) - (1 / (z + a + 2) - 1 / (z + 2)) / 2 - (1 / (z + a + 2) / (z + a + 2) - 1 / (z + 2) / (z + 2)) / 12
 				- 1. / (z + a) - 1. / (z + a + 1)

data/vendor/tomotopy/src/Utils/serializer.hpp

@@ -4,11 +4,11 @@
 #include <string>
 #include <array>
 #include <type_traits>
-#include <Eigen/Dense>
 #include <vector>
-#include "tvector.hpp"
+#include <map>
+#include <unordered_map>
+#include <Eigen/Dense>
 #include "text.hpp"
-#include "SharedString.hpp"
 
 /*
 
@@ -30,6 +30,40 @@ namespace tomoto
 {
 	namespace serializer
 	{
+		struct membuf : std::streambuf 
+		{
+			membuf(char* base, std::ptrdiff_t n) 
+			{
+				this->setg(base, base, base + n);
+			}
+
+			pos_type seekpos(pos_type sp, std::ios_base::openmode which) override {
+				return seekoff(sp - pos_type(off_type(0)), std::ios_base::beg, which);
+			}
+
+			pos_type seekoff(off_type off,
+				std::ios_base::seekdir dir,
+				std::ios_base::openmode which = std::ios_base::in) override {
+				if (dir == std::ios_base::cur)
+					gbump(off);
+				else if (dir == std::ios_base::end)
+					setg(eback(), egptr() + off, egptr());
+				else if (dir == std::ios_base::beg)
+					setg(eback(), eback() + off, egptr());
+				return gptr() - eback();
+			}
+		};
+
+		class imstream : public std::istream
+		{
+			membuf buf;
+		public:
+			imstream(const char* base, std::ptrdiff_t n)
+				: std::istream(&buf), buf((char*)base, n)
+			{
+			}
+		};
+
 		namespace detail
 		{
 			template<class _T> using Invoke = typename _T::type;
@@ -133,15 +167,49 @@ namespace tomoto
 			return Key<_n>{detail::to_arrayz(a)};
 		}
 
+		template<typename _Ty, typename = void>
+		struct Serializer;
+
+		template<typename _Ty, size_t _version = 0, typename = void>
+		struct SerializerV;
+
+		template<typename _Ty>
+		inline void writeToStream(std::ostream& ostr, const _Ty& v)
+		{
+			Serializer<
+				typename std::remove_const<typename std::remove_reference<_Ty>::type>::type
+			>{}.write(ostr, v);
+		}
+
+		template<typename _Ty>
+		inline void readFromStream(std::istream& istr, _Ty& v)
+		{
+			Serializer<
+				typename std::remove_const<typename std::remove_reference<_Ty>::type>::type
+			>{}.read(istr, v);
+		}
+
+		template<typename _Ty>
+		inline _Ty readFromStream(std::istream& istr)
+		{
+			_Ty v;
+			Serializer<
+				typename std::remove_const<typename std::remove_reference<_Ty>::type>::type
+			>{}.read(istr, v);
+			return v;
+		}
+
 		inline void writeMany(std::ostream& ostr)
 		{
 			// do nothing
 		}
 
 		template<typename _FirstTy, typename ... _RestTy>
-		inline typename std::enable_if<!is_key<_FirstTy>::value>::type writeMany(std::ostream& ostr, const _FirstTy& first, _RestTy&&... rest)
+		inline typename std::enable_if<
+			!is_key<typename std::remove_reference<_FirstTy>::type>::value
+		>::type writeMany(std::ostream& ostr, _FirstTy&& first, _RestTy&&... rest)
 		{
-			writeToStream(ostr, first);
+			writeToStream(ostr, std::forward<_FirstTy>(first));
 			writeMany(ostr, std::forward<_RestTy>(rest)...);
 		}
 
@@ -158,9 +226,11 @@ namespace tomoto
 		}
 
 		template<typename _FirstTy, typename ... _RestTy>
-		inline typename std::enable_if<!is_key<_FirstTy>::value>::type readMany(std::istream& istr, _FirstTy& first, _RestTy&&... rest)
+		inline typename std::enable_if<
+			!is_key<typename std::remove_reference<_FirstTy>::type>::value
+		>::type readMany(std::istream& istr, _FirstTy&& first, _RestTy&&... rest)
 		{
-			readFromStream(istr, first);
+			readFromStream(istr, std::forward<_FirstTy>(first));
 			readMany(istr, std::forward<_RestTy>(rest)...);
 		}
 
@@ -234,255 +304,313 @@ namespace tomoto
 		template<typename _Ty, size_t _version>
 		struct hasLoadV : decltype(detail::testLoadV<_Ty, _version>(0)){};
 
-		template<class _Ty>
-		inline typename std::enable_if<std::is_fundamental<_Ty>::value>::type writeToBinStreamImpl(std::ostream& ostr, const _Ty& v)
+		template<typename _Ty>
+		struct Serializer<_Ty, typename std::enable_if<std::is_fundamental<_Ty>::value>::type>
 		{
-			if (!ostr.write((const char*)&v, sizeof(_Ty)))
-				throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			void write(std::ostream& ostr, const _Ty& v)
+			{
+				if (!ostr.write((const char*)&v, sizeof(_Ty)))
+					throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
 
-		template<class _Ty>
-		inline typename std::enable_if<std::is_fundamental<_Ty>::value>::type readFromBinStreamImpl(std::istream& istr, _Ty& v)
-		{
-			if (!istr.read((char*)&v, sizeof(_Ty)))
-				throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			void read(std::istream& istr, _Ty& v)
+			{
+				if (!istr.read((char*)&v, sizeof(_Ty)))
+					throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
+		};
 
-		template<class _Ty>
-		inline typename std::enable_if<hasSave<_Ty>::value>::type writeToBinStreamImpl(std::ostream& ostr, const _Ty& v)
+		template<typename _Ty>
+		struct Serializer<_Ty, typename std::enable_if<hasSave<_Ty>::value>::type>
 		{
-			v.serializerWrite(ostr);
-		}
+			void write(std::ostream& ostr, const _Ty& v)
+			{
+				v.serializerWrite(ostr);
+			}
 
-		template<class _Ty, size_t _version = 0>
-		inline typename std::enable_if<
-			hasSaveV<_Ty, _version>::value && !hasSaveV<_Ty, _version + 1>::value
-		>::type writeToBinStreamImpl(std::ostream& ostr, const _Ty& v)
-		{
-			v.serializerWrite(version_holder<_version>{}, ostr);
-		}
+			void read(std::istream& istr, _Ty& v)
+			{
+				v.serializerRead(istr);
+			}
+		};
 
-		template<class _Ty, size_t _version = 0>
-		inline typename std::enable_if<
-			hasSaveV<_Ty, _version>::value && hasSaveV<_Ty, _version + 1>::value
-		>::type writeToBinStreamImpl(std::ostream& ostr, const _Ty& v)
+		template<typename _Ty>
+		struct Serializer<_Ty, typename std::enable_if<hasSaveV<_Ty, 0>::value>::type>
 		{
-			return writeToBinStreamImpl<_Ty, _version + 1>(ostr, v);
-		}
+			void write(std::ostream& ostr, const _Ty& v)
+			{
+				SerializerV<_Ty>{}.write(ostr, v);
+			}
 
-		template<class _Ty>
-		inline typename std::enable_if<hasLoad<_Ty>::value>::type readFromBinStreamImpl(std::istream& istr, _Ty& v)
+			void read(std::istream& istr, _Ty& v)
+			{
+				SerializerV<_Ty>{}.read(istr, v);
+			}
+		};
+		
+		template<typename _Ty, size_t _version>
+		struct SerializerV<_Ty, _version, typename std::enable_if<
+			hasSaveV<_Ty, _version>::value && !hasSaveV<_Ty, _version + 1>::value
+		>::type>
 		{
-			v.serializerRead(istr);
-		}
+			void write(std::ostream& ostr, const _Ty& v)
+			{
+				v.serializerWrite(version_holder<_version>{}, ostr);
+			}
 
-		template<class _Ty, size_t _version = 0>
-		inline typename std::enable_if<
-			hasLoadV<_Ty, _version>::value && !hasLoadV<_Ty, _version + 1>::value
-		>::type readFromBinStreamImpl(std::istream& istr, _Ty& v)
-		{
-			v.serializerRead(version_holder<_version>{}, istr);
-		}
+			void read(std::istream& istr, _Ty& v)
+			{
+				v.serializerRead(version_holder<_version>{}, istr);
+			}
+		};
 
-		template<class _Ty, size_t _version = 0>
-		inline typename std::enable_if<
-			hasLoadV<_Ty, _version>::value && hasLoadV<_Ty, _version + 1>::value
-		>::type readFromBinStreamImpl(std::istream& istr, _Ty& v)
+		template<typename _Ty, size_t _version>
+		struct SerializerV<_Ty, _version, typename std::enable_if<
+			hasSaveV<_Ty, _version>::value && hasSaveV<_Ty, _version + 1>::value
+		>::type>
 		{
-			auto pos = istr.tellg();
-			try
+			void write(std::ostream& ostr, const _Ty& v)
 			{
-				// try higher version first
-				return readFromBinStreamImpl<_Ty, _version + 1>(istr, v);
+				SerializerV<_Ty, _version + 1>{}.write(ostr, v);
 			}
-			catch (const std::ios_base::failure&)
+
+			void read(std::istream& istr, _Ty& v)
 			{
-				istr.seekg(pos);
-				// try current version if fails
-				v.serializerRead(version_holder<_version>{}, istr);
+				auto pos = istr.tellg();
+				try
+				{
+					// try higher version first
+					return SerializerV<_Ty, _version + 1>{}.read(istr, v);
+				}
+				catch (const std::ios_base::failure&)
+				{
+					istr.seekg(pos);
+					// try current version if fails
+					v.serializerRead(version_holder<_version>{}, istr);
+				}
 			}
-		}
+		};
 
-		template<class _Ty>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const Eigen::Matrix<_Ty, -1, -1>& v)
+		template<typename _Ty>
+		struct Serializer<Eigen::Matrix<_Ty, -1, -1>>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.rows());
-			writeToStream<uint32_t>(ostr, (uint32_t)v.cols());
-			if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
-				throw std::ios_base::failure( std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			using VTy = Eigen::Matrix<_Ty, -1, -1>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeMany(ostr, (uint32_t)v.rows(), (uint32_t)v.cols());
+				if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
+					throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
 
-		template<class _Ty>
-		inline void readFromBinStreamImpl(std::istream& istr, Eigen::Matrix<_Ty, -1, -1>& v)
-		{
-			uint32_t rows = readFromStream<uint32_t>(istr);
-			uint32_t cols = readFromStream<uint32_t>(istr);
-			v = Eigen::Matrix<_Ty, -1, -1>::Zero(rows, cols);
-			if (!istr.read((char*)v.data(), sizeof(_Ty) * rows * cols))
-				throw std::ios_base::failure( std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				uint32_t rows, cols;
+				readMany(istr, rows, cols);
+				v = Eigen::Matrix<_Ty, -1, -1>::Zero(rows, cols);
+				if (!istr.read((char*)v.data(), sizeof(_Ty) * rows * cols))
+					throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
+		};
 
-		template<class _Ty>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const Eigen::Matrix<_Ty, -1, 1>& v)
+		template<typename _Ty>
+		struct Serializer<Eigen::Matrix<_Ty, -1, 1>>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.rows());
-			writeToStream<uint32_t>(ostr, (uint32_t)v.cols());
-			if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
-				throw std::ios_base::failure( std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			using VTy = Eigen::Matrix<_Ty, -1, 1>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeMany(ostr, (uint32_t)v.rows(), (uint32_t)v.cols());
+				if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
+					throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
 
-		template<class _Ty>
-		inline void readFromBinStreamImpl(std::istream& istr, Eigen::Matrix<_Ty, -1, 1>& v)
-		{
-			uint32_t rows = readFromStream<uint32_t>(istr);
-			uint32_t cols = readFromStream<uint32_t>(istr);
-			if (cols != 1) throw std::ios_base::failure( "matrix cols != 1'" );
-			v = Eigen::Matrix<_Ty, -1, 1>::Zero(rows);
-			if (!istr.read((char*)v.data(), sizeof(_Ty) * rows * cols))
-				throw std::ios_base::failure( std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				uint32_t rows, cols;
+				readMany(istr, rows, cols);
+				if (cols != 1) throw std::ios_base::failure("matrix cols != 1");
+				v = Eigen::Matrix<_Ty, -1, -1>::Zero(rows, cols);
+				if (!istr.read((char*)v.data(), sizeof(_Ty) * rows * cols))
+					throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
+		};
 
-		template<class _Ty>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const std::vector<_Ty>& v)
+		template<typename _Ty>
+		struct Serializer<PreventCopy<_Ty>> : public Serializer<_Ty>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.size());
-			for (auto& e : v) writeToStream(ostr, e);
-		}
+		};
 
-		template<class _Ty>
-		inline void readFromBinStreamImpl(std::istream& istr, std::vector<_Ty>& v)
+		template<typename _Ty, typename _Ty2>
+		struct Serializer<DelegateCopy<_Ty, _Ty2>> : public Serializer<_Ty>
 		{
-			uint32_t size = readFromStream<uint32_t>(istr);
-			v.resize(size);
-			for (auto& e : v) readFromStream(istr, e);
-		}
+		};
 
-		template<class _Ty1, class _Ty2>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const std::pair<_Ty1, _Ty2>& v)
+		template<typename _Ty>
+		struct Serializer<std::vector<_Ty>, typename std::enable_if<std::is_fundamental<_Ty>::value>::type>
 		{
-			writeToStream(ostr, v.first);
-			writeToStream(ostr, v.second);
-		}
+			using VTy = std::vector<_Ty>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
+					throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
 
-		template<class _Ty1, class _Ty2>
-		inline void readFromBinStreamImpl(std::istream& istr, std::pair<_Ty1, _Ty2>& v)
-		{
-			readFromStream(istr, v.first);
-			readFromStream(istr, v.second);
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				auto size = readFromStream<uint32_t>(istr);
+				v.resize(size);
+				if (!istr.read((char*)v.data(), sizeof(_Ty) * size))
+					throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
+		};
 
-		template<class _KeyTy, class _ValTy>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const std::unordered_map<_KeyTy, _ValTy>& v)
+		template<typename _Ty>
+		struct Serializer<std::vector<_Ty>, typename std::enable_if<!std::is_fundamental<_Ty>::value>::type>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.size());
-			for (auto& e : v) writeToStream(ostr, e);
-		}
+			using VTy = std::vector<_Ty>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				for (auto& e : v) Serializer<_Ty>{}.write(ostr, e);
+			}
 
-		template<class _KeyTy, class _ValTy>
-		inline void readFromBinStreamImpl(std::istream& istr, std::unordered_map<_KeyTy, _ValTy>& v)
-		{
-			uint32_t size = readFromStream<uint32_t>(istr);
-			v.clear();
-			for (size_t i = 0; i < size; ++i)
+			void read(std::istream& istr, VTy& v)
 			{
-				v.emplace(readFromStream<std::pair<_KeyTy, _ValTy>>(istr));
+				auto size = readFromStream<uint32_t>(istr);
+				v.resize(size);
+				for (auto& e : v) Serializer<_Ty>{}.read(istr, e);
 			}
-		}
+		};
 
-		template<class _Ty, size_t _N>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const std::array<_Ty, _N>& v)
+		template<typename _Ty, size_t n>
+		struct Serializer<std::array<_Ty, n>, typename std::enable_if<std::is_fundamental<_Ty>::value>::type>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.size());
-			for (auto& e : v) writeToStream(ostr, e);
-		}
+			using VTy = std::array<_Ty, n>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
+					throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
 
-		template<class _Ty, size_t _N>
-		inline void readFromBinStreamImpl(std::istream& istr, std::array<_Ty, _N>& v)
-		{
-			uint32_t size = readFromStream<uint32_t>(istr);
-			if (_N != size) throw std::ios_base::failure( text::format("the size of array must be %zd, not %zd", _N, size) );
-			for (auto& e : v) readFromStream(istr, e);
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				auto size = readFromStream<uint32_t>(istr);
+				if (n != size) throw std::ios_base::failure(text::format("the size of array must be %zd, not %zd", n, size));
+				if (!istr.read((char*)v.data(), sizeof(_Ty) * size))
+					throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
+		};
 
-		template<class _Ty>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const tvector<_Ty>& v)
+		template<typename _Ty, size_t n>
+		struct Serializer<std::array<_Ty, n>, typename std::enable_if<!std::is_fundamental<_Ty>::value>::type>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.size());
-			for (auto& e : v) writeToStream(ostr, e);
-		}
+			using VTy = std::array<_Ty, n>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				for (auto& e : v) Serializer<_Ty>{}.write(ostr, e);
+			}
 
-		template<class _Ty>
-		inline void readFromBinStreamImpl(std::istream& istr, tvector<_Ty>& v)
-		{
-			uint32_t size = readFromStream<uint32_t>(istr);
-			v.resize(size);
-			for (auto& e : v) readFromStream(istr, e);
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				auto size = readFromStream<uint32_t>(istr);
+				if (n != size) throw std::ios_base::failure(text::format("the size of array must be %zd, not %zd", n, size));
+				for (auto& e : v) Serializer<_Ty>{}.read(istr, e);
+			}
+		};
 
-		template<class _Ty>
-		inline void writeToBinStreamImpl(std::ostream& ostr, const std::basic_string<_Ty>& v)
+		template<typename _Ty>
+		struct Serializer<std::basic_string<_Ty>>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.size());
-			if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
-				throw std::ios_base::failure( std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			using VTy = std::basic_string<_Ty>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				if (!ostr.write((const char*)v.data(), sizeof(_Ty) * v.size()))
+					throw std::ios_base::failure(std::string("writing type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
 
-		template<class _Ty>
-		inline void readFromBinStreamImpl(std::istream& istr, std::basic_string<_Ty>& v)
-		{
-			uint32_t size = readFromStream<uint32_t>(istr);
-			v.resize(size);
-			if (!istr.read((char*)v.data(), sizeof(_Ty) * v.size()))
-				throw std::ios_base::failure( std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed") );
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				auto size = readFromStream<uint32_t>(istr);
+				v.resize(size);
+				if (!istr.read((char*)v.data(), sizeof(_Ty) * size))
+					throw std::ios_base::failure(std::string("reading type '") + typeid(_Ty).name() + std::string("' is failed"));
+			}
+		};
 
-		inline void writeToBinStreamImpl(std::ostream& ostr, const SharedString& v)
+		template<typename _Ty1, typename _Ty2>
+		struct Serializer<std::pair<_Ty1, _Ty2>>
 		{
-			writeToStream<uint32_t>(ostr, (uint32_t)v.size());
-			if (!ostr.write((const char*)v.data(), v.size()))
-				throw std::ios_base::failure(std::string("writing type 'SharedString' is failed"));
-		}
+			using VTy = std::pair<_Ty1, _Ty2>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeMany(ostr, v.first, v.second);
+			}
 
-		inline void readFromBinStreamImpl(std::istream& istr, SharedString& v)
-		{
-			uint32_t size = readFromStream<uint32_t>(istr);
-			std::vector<char> t(size);
-			if (!istr.read((char*)t.data(), t.size()))
-				throw std::ios_base::failure(std::string("reading type 'SharedString' is failed"));
-			v = SharedString{ t.data(), t.data() + t.size() };
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				readMany(istr, v.first, v.second);
+			}
+		};
 
-		template<class _Ty>
-		inline typename std::enable_if<std::is_abstract<_Ty>::value>::type writeToBinStreamImpl(std::ostream& ostr, const std::unique_ptr<_Ty>& v)
+		template<typename _Ty1, typename _Ty2>
+		struct Serializer<std::unordered_map<_Ty1, _Ty2>>
 		{
-			_Ty::serializerWrite(v, ostr);
-		}
+			using VTy = std::unordered_map<_Ty1, _Ty2>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				for (auto& e : v) writeToStream(ostr, e);
+			}
 
-		template<class _Ty>
-		inline typename std::enable_if<std::is_abstract<_Ty>::value>::type readFromBinStreamImpl(std::istream& istr, std::unique_ptr<_Ty>& v)
-		{
-			_Ty::serializerRead(v, istr);
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				auto size = readFromStream<uint32_t>(istr);
+				v.clear();
+				for (size_t i = 0; i < size; ++i)
+				{
+					v.emplace(readFromStream<std::pair<_Ty1, _Ty2>>(istr));
+				}
+			}
+		};
 
-		template<typename _Ty> 
-		inline void writeToStream(std::ostream& ostr, const _Ty& v)
+		template<typename _Ty1, typename _Ty2>
+		struct Serializer<std::map<_Ty1, _Ty2>>
 		{
-			return writeToBinStreamImpl(ostr, v);
-		}
+			using VTy = std::map<_Ty1, _Ty2>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(ostr, (uint32_t)v.size());
+				for (auto& e : v) writeToStream(ostr, e);
+			}
 
-		template<typename _Ty> 
-		inline void readFromStream(std::istream& istr, _Ty& v)
-		{
-			return readFromBinStreamImpl(istr, v);
-		}
+			void read(std::istream& istr, VTy& v)
+			{
+				auto size = readFromStream<uint32_t>(istr);
+				v.clear();
+				for (size_t i = 0; i < size; ++i)
+				{
+					v.emplace(readFromStream<std::pair<_Ty1, _Ty2>>(istr));
+				}
+			}
+		};
 
 		template<typename _Ty>
-		inline _Ty readFromStream(std::istream& istr)
+		struct Serializer<std::unique_ptr<_Ty>, typename std::enable_if<std::is_abstract<_Ty>::value>::type>
 		{
-			_Ty v;
-			readFromBinStreamImpl(istr, v);
-			return v;
-		}
+			using VTy = std::unique_ptr<_Ty>;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				_Ty::serializerWrite(v, ostr);
+			}
+
+			void read(std::istream& istr, VTy& v)
+			{
+				_Ty::serializerRead(v, istr);
+			}
+		};
 
 		static auto taggedDataKey = to_key("TPTK");