Reworking interface for shared memory, initial commit with new low level classes, not yet working

common/shared/shared_memory.h

@@ -0,0 +1,82 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "../expected.h"
+#include "shared_memory_error.h"
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/managed_mapped_file.hpp>
+#include <memory>
+
+namespace eq
+{
+	namespace shared
+	{
+		namespace detail {
+			typedef boost::interprocess::managed_mapped_file::segment_manager segment_manager_t;
+			typedef boost::interprocess::allocator<void, segment_manager_t> allocator;
+		}
+
+		using allocator = detail::allocator;
+
+		class shared_memory
+		{
+		public:
+			shared_memory(const std::string &path, size_t sz) {
+				_path = path;
+				_sz = sz;
+			}
+
+			~shared_memory() = default;
+
+			template<typename Ty>
+			expected<handle<Ty>, shared_memory_error> map(const std::string& key) {
+				if (!_memory) {
+					try {
+						_memory.reset(new boost::interprocess::managed_mapped_file(boost::interprocess::open_or_create, _path.c_str(), _sz));
+					}
+					catch (boost::interprocess::interprocess_exception) {
+						return eq::make_unexpected(shared_memory_error::error_mapping_memory);
+					}
+				}
+
+				handle<Ty> inst;
+				auto ir = inst.initialize(key, _memory.get());
+				if (ir) {
+					return eq::expected<handle<Ty>, shared_memory_error>(inst);
+				}
+				else {
+					return make_unexpected(ir.error());
+				}
+
+				return expected<handle<Ty>, shared_memory_error>(inst);
+			}
+
+			template<typename Ty, typename... Args>
+			Ty construct(Args&&... args) {
+				return Ty(std::forward<Args>(args)..., _memory->get_allocator<void>());
+			}
+		private:
+			std::unique_ptr<boost::interprocess::managed_mapped_file> _memory;
+			std::string _path;
+			size_t _sz;
+		};
+	}
+}

common/shared/shared_memory_error.h

@@ -0,0 +1,32 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+namespace eq
+{
+	namespace shared
+	{
+		enum class shared_memory_error
+		{
+			no_error,
+			error_mapping_memory,
+			error_alloc
+		};
+	}
+}

common/shared/shared_memory_handle.h

@@ -0,0 +1,70 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_error.h"
+#include "../expected.h"
+
+#include <boost/interprocess/managed_mapped_file.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <type_traits>
+
+namespace eq
+{
+	namespace shared
+	{
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory {
+				static_assert(std::is_trivially_constructible<Ty>::value, 
+					"Non-specialized types must be trivially constructible, consider creating a type_factory in eq::shared::detail if you want to use this type.");
+				Ty*	create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<Ty>(key.c_str())();
+				}
+			};
+		}
+
+		template<typename Ty>
+		class handle {
+		public:
+			handle() = default;
+			~handle() = default;
+
+			expected<void, shared_memory_error> initialize(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+				try {
+					_mmf = mmf;
+					detail::type_factory<Ty> fac;
+					_ptr = fac.create(key, mmf);
+					return expected<void, shared_memory_error>();
+				}
+				catch (boost::interprocess::interprocess_exception) {
+					return make_unexpected(shared_memory_error::error_mapping_memory);
+				}
+			}
+
+			operator Ty& () {
+				return *_ptr;
+			}
+		private:
+			Ty* _ptr;
+			boost::interprocess::managed_mapped_file* _mmf;
+		};
+	}
+}

common/shared/shared_memory_list.h

@@ -0,0 +1,43 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/list.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ty>
+		using list = boost::interprocess::list<Ty, boost::interprocess::allocator<Ty, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory<list<Ty>>
+			{
+				list<Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<list<Ty>>(key.c_str())(mmf->get_allocator<void>());
+				}
+			};
+		}
+	}
+}

common/shared/shared_memory_map.h

@@ -0,0 +1,77 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/map.hpp>
+#include <boost/interprocess/containers/flat_map.hpp>
+#include <boost/unordered_map.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ky, typename Ty>
+		using unordered_map = boost::unordered_map<int,
+			Ty,
+			boost::hash<Ky>,
+			std::equal_to<Ky>,
+			boost::interprocess::allocator<std::pair<const Ky, Ty>, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		template<typename Ky, typename Ty>
+		using map = boost::interprocess::map<Ky,
+			Ty,
+			std::less<Ky>,
+			boost::interprocess::allocator<std::pair<const Ky, Ty>, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		template<typename Ky, typename Ty>
+		using flat_map = boost::interprocess::flat_map<Ky,
+			Ty,
+			std::less<Ky>,
+			boost::interprocess::allocator<std::pair<const Ky, Ty>, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		namespace detail
+		{
+			template<typename Ky, typename Ty>
+			struct type_factory<unordered_map<Ky, Ty>>
+			{
+				unordered_map<Ky, Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<unordered_map<Ky, Ty>>(key.c_str())(3, boost::hash<Ky>(), std::equal_to<Ky>(), mmf->get_allocator<void>());
+				}
+			};
+
+			template<typename Ky, typename Ty>
+			struct type_factory<map<Ky, Ty>>
+			{
+				map<Ky, Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<map<Ky, Ty>>(key.c_str())(std::less<Ky>(), mmf->get_allocator<void>());
+				}
+			};
+
+			template<typename Ky, typename Ty>
+			struct type_factory<flat_map<Ky, Ty>>
+			{
+				flat_map<Ky, Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<flat_map<Ky, Ty>>(key.c_str())(std::less<Ky>(), mmf->get_allocator<void>());
+				}
+			};
+		}
+	}
+}

common/shared/shared_memory_string.h

@@ -0,0 +1,52 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/string.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ty>
+		using basic_string = boost::interprocess::basic_string<Ty, std::char_traits<Ty>, boost::interprocess::allocator<Ty, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		using string = basic_string<char>;
+
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory<basic_string<Ty>>
+			{
+				list<Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<list<Ty>>(key.c_str())(mmf->get_allocator<void>());
+				}
+			};
+		}
+
+		template<typename Ty>
+		std::basic_string<Ty> to_std_string(const eq::shared::basic_string<Ty> &in) {
+			return std::basic_string<Ty>(in.begin(), in.end());
+		}
+	}
+}

common/shared/shared_memory_vector.h

@@ -0,0 +1,43 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/vector.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ty>
+		using vector = boost::interprocess::vector<Ty, boost::interprocess::allocator<Ty, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory<vector<Ty>>
+			{
+				vector<Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<vector<Ty>>(key.c_str())(mmf->get_allocator<void>());
+				}
+			};
+		}
+	}
+}