tomoto 0.4.0 → 0.4.1

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

@@ -58,6 +58,7 @@ namespace tomoto
 			}
 
 			DEFINE_SERIALIZER_CALLBACK(onRead, mean, cov);
+			DEFINE_HASHER(mean, cov);
 		private:
 			void onRead() 
 			{

data/vendor/tomotopy/src/Utils/SharedString.cpp

@@ -0,0 +1,134 @@
+#include "SharedString.h"
+
+namespace tomoto
+{
+    void SharedString::incref()
+    {
+        if (ptr)
+        {
+            ++*(size_t*)ptr;
+        }
+    }
+
+    void SharedString::decref()
+    {
+        if (ptr)
+        {
+            if (--*(size_t*)ptr == 0)
+            {
+                delete[] ptr;
+                ptr = nullptr;
+            }
+        }
+    }
+
+    void SharedString::init(const char* _begin, const char* _end)
+    {
+        ptr = new char[_end - _begin + 9];
+        *(size_t*)ptr = 1;
+        len = _end - _begin;
+        std::memcpy((void*)(ptr + 8), _begin, _end - _begin);
+        ((char*)ptr)[_end - _begin + 8] = 0;
+    }
+
+    SharedString::SharedString()
+    {
+    }
+
+    SharedString::SharedString(const char* _begin, const char* _end)
+    {
+        init(_begin, _end);
+    }
+
+    SharedString::SharedString(const char* _ptr)
+    {
+        if (_ptr)
+        {
+            init(_ptr, _ptr + std::strlen(_ptr));
+        }
+    }
+
+    SharedString::SharedString(const std::string& str)
+    {
+        if (!str.empty())
+        {
+            init(str.data(), str.data() + str.size());
+        }
+    }
+
+    SharedString::SharedString(const SharedString& o) noexcept
+        : ptr{ o.ptr }, len{ o.len }
+    {
+        incref();
+    }
+
+    SharedString::SharedString(SharedString&& o) noexcept
+    {
+        std::swap(ptr, o.ptr);
+        std::swap(len, o.len);
+    }
+
+    SharedString::~SharedString()
+    {
+        decref();
+    }
+
+    SharedString& SharedString::operator=(const SharedString& o)
+    {
+        if (this != &o)
+        {
+            decref();
+            ptr = o.ptr;
+            len = o.len;
+            incref();
+        }
+        return *this;
+    }
+
+    SharedString& SharedString::operator=(SharedString&& o) noexcept
+    {
+        std::swap(ptr, o.ptr);
+        std::swap(len, o.len);
+        return *this;
+    }
+
+    SharedString::operator std::string() const
+    {
+        if (!ptr) return {};
+        return { ptr + 8, ptr + 8 + len };
+    }
+
+    const char* SharedString::c_str() const
+    {
+        if (!ptr) return "";
+        return ptr + 8;
+    }
+
+    std::string SharedString::substr(size_t start, size_t len) const
+    {
+        return { c_str() + start, c_str() + start + len };
+    }
+
+    bool SharedString::operator==(const SharedString& o) const
+    {
+        if (ptr == o.ptr) return true;
+        if (size() != o.size()) return false;
+        return std::equal(begin(), end(), o.begin());
+    }
+
+    bool SharedString::operator==(const std::string& o) const
+    {
+        if (size() != o.size()) return false;
+        return std::equal(begin(), end(), o.begin());
+    }
+
+    bool SharedString::operator!=(const SharedString& o) const
+    {
+        return !operator==(o);
+    }
+
+    bool SharedString::operator!=(const std::string& o) const
+    {
+        return !operator==(o);
+    }
+}

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

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <string>
+#include "serializer.hpp"
+
+namespace tomoto
+{
+	class SharedString
+	{
+		const char* ptr = nullptr;
+		size_t len = 0;
+
+		void incref();
+
+		void decref();
+
+		void init(const char* _begin, const char* _end);
+
+	public:
+
+		SharedString();
+		explicit SharedString(const char* _begin, const char* _end);
+		explicit SharedString(const char* _ptr);
+		explicit SharedString(const std::string& str);
+		SharedString(const SharedString& o) noexcept;
+		SharedString(SharedString&& o) noexcept;
+		~SharedString();
+		SharedString& operator=(const SharedString& o);
+		SharedString& operator=(SharedString&& o) noexcept;
+
+		size_t size() const
+		{
+			if (ptr) return len;
+			return 0;
+		}
+
+		bool empty() const
+		{
+			return size() == 0;
+		}
+
+		operator std::string() const;
+
+		const char* c_str() const;
+
+		const char* data() const
+		{
+			return c_str();
+		}
+
+		const char* begin() const
+		{
+			return data();
+		}
+
+		const char* end() const
+		{
+			return data() + size();
+		}
+
+		std::string substr(size_t start, size_t len) const;
+
+		bool operator==(const SharedString& o) const;
+		bool operator==(const std::string& o) const;
+
+		bool operator!=(const SharedString& o) const;
+		bool operator!=(const std::string& o) const;
+	};
+
+	namespace serializer
+	{
+		template<>
+		struct Serializer<SharedString>
+		{
+			using VTy = SharedString;
+			void write(std::ostream& ostr, const VTy& v)
+			{
+				writeToStream(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"));
+			}
+
+			void read(std::istream& istr, VTy& v)
+			{
+				auto 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() };
+			}
+		};
+	}
+}
+
+namespace std
+{
+	template <> struct hash<tomoto::SharedString>
+	{
+		size_t operator()(const tomoto::SharedString& x) const
+		{
+			return hash<string>{}(x);
+		}
+	};
+}

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

@@ -0,0 +1,166 @@
+#include "serializer.hpp"
+
+namespace tomoto
+{
+	namespace serializer
+	{
+		membuf::membuf(bool read, bool write, char* base, std::ptrdiff_t n)
+		{
+			if (read)
+			{
+				this->setg(base, base, base + n);
+			}
+
+			if (write)
+			{
+				this->setp(base, base + n);
+			}
+		}
+
+		membuf::~membuf() = default;
+
+		std::streampos membuf::seekpos(pos_type sp, std::ios_base::openmode which) 
+		{
+			return seekoff(sp - pos_type(off_type(0)), std::ios_base::beg, which);
+		}
+
+		std::streampos membuf::seekoff(off_type off,
+			std::ios_base::seekdir dir,
+			std::ios_base::openmode which
+		) 
+		{
+			if (which & std::ios_base::in)
+			{
+				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());
+			}
+			if (which & std::ios_base::out)
+			{
+				if (dir == std::ios_base::cur)
+					pbump(off);
+				else if (dir == std::ios_base::end)
+					setp(epptr() + off, epptr());
+				else if (dir == std::ios_base::beg)
+					setp(pbase() + off, epptr());
+
+				if (!(which & std::ios_base::in))
+				{
+					return pptr() - pbase();
+				}
+			}
+			return gptr() - eback();
+		}
+
+		imstream::imstream(const char* base, std::ptrdiff_t n)
+			: std::istream(&buf), buf(true, false, (char*)base, n)
+		{
+		}
+
+		imstream::~imstream() = default;
+
+		omstream::omstream(char* base, std::ptrdiff_t n)
+			: std::ostream(&buf), buf(false, true, (char*)base, n)
+		{
+		}
+
+		omstream::~omstream() = default;
+
+
+		BlockStreamBuffer::BlockStreamBuffer(size_t _block_size) : block_size{ _block_size }
+		{
+			buffers.emplace_back(std::make_unique<uint8_t[]>(block_size));
+			this->setp((char*)buffers.back().get(), (char*)buffers.back().get() + block_size);
+		}
+
+		BlockStreamBuffer::~BlockStreamBuffer() = default;
+
+		int BlockStreamBuffer::overflow(int c)
+		{
+			if (this->pptr() == this->epptr())
+			{
+				buffers.emplace_back(std::make_unique<uint8_t[]>(block_size));
+				this->setp((char*)buffers.back().get(), (char*)buffers.back().get() + block_size);
+			}
+			else
+			{
+				*(this->pptr()) = c;
+				this->pbump(1);
+			}
+			return c;
+		}
+
+		std::streamsize BlockStreamBuffer::xsputn(const char* s, std::streamsize n)
+		{
+			auto rest = n;
+			auto buf_remain = this->epptr() - this->pptr();
+			while (rest > buf_remain)
+			{
+				std::copy(s, s + buf_remain, this->pptr());
+				this->pbump(buf_remain);
+				buffers.emplace_back(std::make_unique<uint8_t[]>(block_size));
+				this->setp((char*)buffers.back().get(), (char*)buffers.back().get() + block_size);
+				rest -= buf_remain;
+				s += buf_remain;
+				buf_remain = block_size;
+			}
+			std::copy(s, s + rest, this->pptr());
+			this->pbump(rest);
+			return n;
+		}
+
+		size_t BlockStreamBuffer::totalSize() const
+		{
+			return (buffers.size() - 1) * block_size + (this->pptr() - this->pbase());
+		}
+
+		TaggedDataMap readTaggedDataMap(std::istream& istr, uint32_t version)
+		{
+			std::unordered_map<std::string, std::pair<std::streampos, std::streampos>> ret;
+			TaggedDataHeader h;
+			do
+			{
+				istr.read((char*)&h, sizeof(h));
+				if (h.key != taggedDataKeyUint)
+				{
+					throw UnfitException("tagged data key is not found");
+				}
+				const std::streampos totsize_pos = istr.tellg() - (std::streamoff)16;
+				std::array<char, 256> key;
+				istr.read(key.data(), h.keysize);
+				const std::streampos start_pos = istr.tellg();
+				const std::streampos end_pos = totsize_pos + (std::streamoff)h.totsize;
+				ret.emplace(std::string{ key.data(), h.keysize }, std::make_pair(start_pos, end_pos));
+				ret[""] = std::make_pair(start_pos, end_pos);
+				istr.seekg(end_pos);
+			} while (h.trailing_cnt);
+			return ret;
+		}
+
+		uint64_t computeFastHash(const void* data, size_t size, uint64_t seed)
+		{
+			for (size_t i = 0; i < size / 4; ++i) 
+			{
+				uint32_t x = ((const uint32_t*)data)[i];
+				x = ((x >> 16) ^ x) * 0x45d9f3b;
+				x = ((x >> 16) ^ x) * 0x45d9f3b;
+				x = (x >> 16) ^ x;
+				seed ^= x + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+			}
+
+			if (size % 4)
+			{
+				uint32_t x = 0;
+				memcpy(&x, (const char*)data + (size / 4) * 4, size % 4);
+				x = ((x >> 16) ^ x) * 0x45d9f3b;
+				x = ((x >> 16) ^ x) * 0x45d9f3b;
+				x = (x >> 16) ^ x;
+				seed ^= x + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+			}
+			return seed;
+		}
+	}
+}