Browse Source
Add i18n namespace. Switch to using hash strings for localized strings. Change settings to be dict-based. Improve path finding on windows. Improve window management. Add serializer and deserializer template classes
master
66 changed files with 2634 additions and 1337 deletions
Split View
Diff Options
-
+1 -0CMakeLists.txt
-
+2 -3CONTRIBUTING.md
-
+4 -4README.md
-
+250 -94src/application.cpp
-
+66 -16src/application.hpp
-
+1 -1src/color/aces.hpp
-
+0 -26src/debug/log.cpp
-
+12 -31src/debug/log.hpp
-
+6 -6src/event/queue.hpp
-
+18 -13src/game/context.hpp
-
+1 -1src/game/controls.cpp
-
+21 -40src/game/fonts.cpp
-
+11 -39src/game/graphics.cpp
-
+0 -101src/game/save.cpp
-
+67 -0src/game/settings.hpp
-
+211 -208src/game/state/boot.cpp
-
+2 -2src/game/state/boot.hpp
-
+11 -7src/game/state/controls-menu.cpp
-
+12 -12src/game/state/credits.cpp
-
+10 -6src/game/state/extras-menu.cpp
-
+11 -11src/game/state/gamepad-config-menu.cpp
-
+75 -123src/game/state/graphics-menu.cpp
-
+11 -11src/game/state/keyboard-config-menu.cpp
-
+44 -45src/game/state/language-menu.cpp
-
+18 -17src/game/state/main-menu.cpp
-
+13 -28src/game/state/nest-selection.cpp
-
+10 -17src/game/state/nuptial-flight.cpp
-
+14 -11src/game/state/options-menu.cpp
-
+13 -10src/game/state/pause-menu.cpp
-
+17 -21src/game/state/sound-menu.cpp
-
+7 -13src/game/state/splash.cpp
-
+13 -17src/game/strings.cpp
-
+42 -0src/game/strings.hpp
-
+4 -4src/game/system/subterrain.cpp
-
+51 -128src/game/world.cpp
-
+21 -21src/gl/gl.hpp
-
+26 -0src/i18n/i18n.hpp
-
+51 -0src/i18n/string-map.cpp
-
+14 -22src/i18n/string-map.hpp
-
+14 -16src/i18n/string-table.hpp
-
+56 -10src/input/event.hpp
-
+28 -10src/main.cpp
-
+3 -1src/render/anti-aliasing-method.hpp
-
+1 -0src/render/passes/fxaa-pass.cpp
-
+0 -1src/render/passes/ground-pass.cpp
-
+0 -2src/render/passes/material-pass.cpp
-
+0 -1src/render/passes/sky-pass.cpp
-
+176 -0src/resources/deserialize-context.cpp
-
+152 -0src/resources/deserialize-context.hpp
-
+10 -23src/resources/deserialize-error.hpp
-
+125 -0src/resources/deserializer.cpp
-
+42 -0src/resources/deserializer.hpp
-
+43 -0src/resources/dict-loader.cpp
-
+32 -14src/resources/resource-loader.cpp
-
+31 -0src/resources/resource-manager.cpp
-
+2 -0src/resources/resource-manager.hpp
-
+144 -0src/resources/serialize-context.cpp
-
+100 -0src/resources/serialize-context.hpp
-
+33 -0src/resources/serialize-error.hpp
-
+120 -0src/resources/serializer.cpp
-
+42 -0src/resources/serializer.hpp
-
+43 -101src/resources/string-table-loader.cpp
-
+168 -0src/utility/dict.cpp
-
+34 -0src/utility/dict.hpp
-
+54 -35src/utility/paths.cpp
-
+20 -14src/utility/paths.hpp
+ 1
- 0
CMakeLists.txt
View File
+ 2
- 3
CONTRIBUTING.md
View File
+ 4
- 4
README.md
View File
+ 250
- 94
src/application.cpp
View File
+ 66
- 16
src/application.hpp
View File
+ 1
- 1
src/color/aces.hpp
View File
+ 0
- 26
src/debug/log.cpp
View File
+ 12
- 31
src/debug/log.hpp
View File
+ 6
- 6
src/event/queue.hpp
View File
+ 18
- 13
src/game/context.hpp
View File
+ 1
- 1
src/game/controls.cpp
View File
+ 21
- 40
src/game/fonts.cpp
View File
+ 11
- 39
src/game/graphics.cpp
View File
+ 0
- 101
src/game/save.cpp
View File
| @ -1,101 +0,0 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "game/save.hpp" | |||
| #include "application.hpp" | |||
| #include "debug/log.hpp" | |||
| #include "resources/json.hpp" | |||
| #include <fstream> | |||
| namespace game { | |||
| namespace save { | |||
| void colony(game::context& ctx) | |||
| { | |||
| std::filesystem::path path = ctx.saves_path / "colony.sav"; | |||
| const std::string path_string = path.string(); | |||
| debug::log::trace("Saving colony to \"{}\"...", path_string); | |||
| try | |||
| { | |||
| // Construct JSON data describing the colony | |||
| json data; | |||
| auto& colony = data["colony"]; | |||
| { | |||
| auto& species = colony["species"]; | |||
| { | |||
| auto& morphology = species["morphology"]; | |||
| { | |||
| } | |||
| auto& diet = species["diet"]; | |||
| auto& aggression = species["aggression"]; | |||
| auto& nest = species["nest"]; | |||
| } | |||
| auto& habitat = colony["habitat"]; | |||
| { | |||
| auto& biome = habitat["biome"]; | |||
| auto& nest = habitat["nest"]; | |||
| { | |||
| nest["entrance"] = {0, 0, 0}; | |||
| } | |||
| } | |||
| auto& members = colony["members"]; | |||
| members = json::array(); | |||
| { | |||
| } | |||
| } | |||
| std::ofstream file(path); | |||
| file << data; | |||
| debug::log::trace("Saved colony to \"{}\"", path_string); | |||
| } | |||
| catch (...) | |||
| { | |||
| debug::log::error("Failed to save colony to \"{}\"", path_string); | |||
| } | |||
| } | |||
| void config(game::context& ctx) | |||
| { | |||
| std::filesystem::path path = ctx.config_path / "config.json"; | |||
| const std::string path_string = path.string(); | |||
| debug::log::trace("Saving config to \"{}\"...", path_string); | |||
| try | |||
| { | |||
| std::ofstream file(path); | |||
| file << *(ctx.config); | |||
| debug::log::trace("Saved config to \"{}\"", path_string); | |||
| } | |||
| catch (...) | |||
| { | |||
| debug::log::error("Failed to save config to \"{}\"", path_string); | |||
| } | |||
| } | |||
| } // namespace save | |||
| } // namespace game | |||
+ 67
- 0
src/game/settings.hpp
View File
| @ -0,0 +1,67 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_GAME_SETTINGS_HPP | |||
| #define ANTKEEPER_GAME_SETTINGS_HPP | |||
| #include "game/context.hpp" | |||
| #include "debug/log.hpp" | |||
| namespace game { | |||
| /** | |||
| * Reads a setting if found, inserts a setting if not found, and overwrites a setting if a type mismatch occurs. | |||
| * | |||
| * @tparam T Setting value type. | |||
| * | |||
| * @param[in] ctx Game context. | |||
| * @param[in] key Setting key. | |||
| * @param[in,out] Setting value. | |||
| * | |||
| * @return `true` if the setting was read, `false` if the setting was written. | |||
| */ | |||
| template <class T> | |||
| bool read_or_write_setting(game::context& ctx, std::uint32_t key, T& value) | |||
| { | |||
| if (auto i = ctx.settings->find(key); i != ctx.settings->end()) | |||
| { | |||
| try | |||
| { | |||
| value = std::any_cast<T>(i->second); | |||
| } | |||
| catch (const std::bad_any_cast& e) | |||
| { | |||
| debug::log::error("Setting type mismatch ({:x}={})", key, value); | |||
| i->second = value; | |||
| return false; | |||
| } | |||
| } | |||
| else | |||
| { | |||
| debug::log::trace("Setting key not found ({:x}={})", key, value); | |||
| (*ctx.settings)[key] = value; | |||
| return false; | |||
| } | |||
| return true; | |||
| } | |||
| } // namespace game | |||
| #endif // ANTKEEPER_GAME_SETTINGS_HPP | |||
+ 211
- 208
src/game/state/boot.cpp
View File
+ 2
- 2
src/game/state/boot.hpp
View File
+ 11
- 7
src/game/state/controls-menu.cpp
View File
+ 12
- 12
src/game/state/credits.cpp
View File
+ 10
- 6
src/game/state/extras-menu.cpp
View File
+ 11
- 11
src/game/state/gamepad-config-menu.cpp
View File
+ 75
- 123
src/game/state/graphics-menu.cpp
View File
+ 11
- 11
src/game/state/keyboard-config-menu.cpp
View File
+ 44
- 45
src/game/state/language-menu.cpp
View File
+ 18
- 17
src/game/state/main-menu.cpp
View File
+ 13
- 28
src/game/state/nest-selection.cpp
View File
+ 10
- 17
src/game/state/nuptial-flight.cpp
View File
+ 14
- 11
src/game/state/options-menu.cpp
View File
+ 13
- 10
src/game/state/pause-menu.cpp
View File
+ 17
- 21
src/game/state/sound-menu.cpp
View File
+ 7
- 13
src/game/state/splash.cpp
View File
src/game/save.hpp → src/game/strings.cpp
View File
+ 42
- 0
src/game/strings.hpp
View File
| @ -0,0 +1,42 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_GAME_STRINGS_HPP | |||
| #define ANTKEEPER_GAME_STRINGS_HPP | |||
| #include "game/context.hpp" | |||
| #include <cstdint> | |||
| #include <string> | |||
| namespace game { | |||
| /** | |||
| * Returns a localized string. | |||
| * | |||
| * @param[in] ctx Game context. | |||
| * @param[in] key String key. | |||
| * @param[out] string String value. | |||
| * | |||
| * @return `true` if the string was found, `false` otherwise. | |||
| */ | |||
| [[nodiscard]] std::string get_string(const game::context& ctx, std::uint32_t key); | |||
| } // namespace game | |||
| #endif // ANTKEEPER_GAME_STRINGS_HPP | |||
+ 4
- 4
src/game/system/subterrain.cpp
View File
+ 51
- 128
src/game/world.cpp
View File
+ 21
- 21
src/gl/gl.hpp
View File
+ 26
- 0
src/i18n/i18n.hpp
View File
| @ -0,0 +1,26 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_I18N_HPP | |||
| #define ANTKEEPER_I18N_HPP | |||
| /// Internationalization and localization. | |||
| namespace i18n {} | |||
| #endif // ANTKEEPER_I18N_HPP | |||
+ 51
- 0
src/i18n/string-map.cpp
View File
| @ -0,0 +1,51 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "i18n/string-map.hpp" | |||
| #include "utility/hash/fnv1a.hpp" | |||
| #include <algorithm> | |||
| namespace i18n { | |||
| void build_string_map(const string_table& table, std::size_t key_column, std::size_t value_column, string_map& map) | |||
| { | |||
| map.clear(); | |||
| const std::size_t max_column = std::max<std::size_t>(key_column, value_column); | |||
| for (const auto& row: table) | |||
| { | |||
| if (row.size() <= max_column) | |||
| { | |||
| continue; | |||
| } | |||
| const auto& value_string = row[value_column]; | |||
| if (value_string.empty()) | |||
| { | |||
| continue; | |||
| } | |||
| const auto& key_string = row[key_column]; | |||
| const std::uint32_t key_hash = hash::fnv1a32(key_string.c_str(), key_string.length()); | |||
| map[key_hash] = row[value_column]; | |||
| } | |||
| } | |||
| } // namespace i18n | |||
src/resources/string-table.hpp → src/i18n/string-map.hpp
View File
src/utility/type-id.hpp → src/i18n/string-table.hpp
View File
+ 56
- 10
src/input/event.hpp
View File
+ 28
- 10
src/main.cpp
View File
+ 3
- 1
src/render/anti-aliasing-method.hpp
View File
+ 1
- 0
src/render/passes/fxaa-pass.cpp
View File
+ 0
- 1
src/render/passes/ground-pass.cpp
View File
+ 0
- 2
src/render/passes/material-pass.cpp
View File
+ 0
- 1
src/render/passes/sky-pass.cpp
View File
+ 176
- 0
src/resources/deserialize-context.cpp
View File
| @ -0,0 +1,176 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "resources/deserialize-context.hpp" | |||
| #include "resources/deserialize-error.hpp" | |||
| #include <physfs.h> | |||
| deserialize_context::deserialize_context(void* handle): | |||
| handle(handle), | |||
| m_eof(false), | |||
| m_error(false) | |||
| {} | |||
| std::size_t deserialize_context::read8(std::byte* data, std::size_t count) | |||
| { | |||
| const PHYSFS_sint64 status = PHYSFS_readBytes(reinterpret_cast<PHYSFS_File*>(handle), data, count); | |||
| if (status < 0) | |||
| { | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return 0; | |||
| } | |||
| if (status != count) | |||
| { | |||
| m_eof = true; | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return static_cast<std::size_t>(count); | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t deserialize_context::read16_le(std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| PHYSFS_uint16* data16 = reinterpret_cast<PHYSFS_uint16*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if (!PHYSFS_readULE16(file, data16)) | |||
| { | |||
| m_eof = (PHYSFS_eof(file) != 0); | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| ++data16; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t deserialize_context::read16_be(std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| PHYSFS_uint16* data16 = reinterpret_cast<PHYSFS_uint16*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if (!PHYSFS_readUBE16(file, data16)) | |||
| { | |||
| m_eof = (PHYSFS_eof(file) != 0); | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| ++data16; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t deserialize_context::read32_le(std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| PHYSFS_uint32* data32 = reinterpret_cast<PHYSFS_uint32*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if (!PHYSFS_readULE32(file, data32)) | |||
| { | |||
| m_eof = (PHYSFS_eof(file) != 0); | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| ++data32; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t deserialize_context::read32_be(std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| PHYSFS_uint32* data32 = reinterpret_cast<PHYSFS_uint32*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if (!PHYSFS_readUBE32(file, data32)) | |||
| { | |||
| m_eof = (PHYSFS_eof(file) != 0); | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| ++data32; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t deserialize_context::read64_le(std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| PHYSFS_uint64* data64 = reinterpret_cast<PHYSFS_uint64*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if (!PHYSFS_readULE64(file, data64)) | |||
| { | |||
| m_eof = (PHYSFS_eof(file) != 0); | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| ++data64; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t deserialize_context::read64_be(std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| PHYSFS_uint64* data64 = reinterpret_cast<PHYSFS_uint64*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if (!PHYSFS_readUBE64(file, data64)) | |||
| { | |||
| m_eof = (PHYSFS_eof(file) != 0); | |||
| m_error = true; | |||
| throw deserialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| ++data64; | |||
| } | |||
| return count; | |||
| } | |||
+ 152
- 0
src/resources/deserialize-context.hpp
View File
| @ -0,0 +1,152 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_RESOURCES_DESERIALIZE_CONTEXT_HPP | |||
| #define ANTKEEPER_RESOURCES_DESERIALIZE_CONTEXT_HPP | |||
| #include <cstddef> | |||
| #include <bit> | |||
| /** | |||
| * Provides access to a deserialization state. | |||
| */ | |||
| struct deserialize_context | |||
| { | |||
| public: | |||
| /** | |||
| * Reads 8-bit (byte) data. | |||
| * | |||
| * @param data Pointer to data source. | |||
| * @param count Number of bytes to read. | |||
| * | |||
| * @return Number of bytes read. | |||
| * | |||
| * @throw deserialize_error Read error. | |||
| */ | |||
| std::size_t read8(std::byte* data, std::size_t count) noexcept(false); | |||
| /** | |||
| * Reads 16-bit (word) data. | |||
| * | |||
| * @tparam Endian Endianness of the read operation. | |||
| * | |||
| * @param data Pointer to data destination. | |||
| * @param count Number of words to read. | |||
| * | |||
| * @return Number of words read. | |||
| * | |||
| * @throw deserialize_error Read error. | |||
| */ | |||
| template <std::endian Endian = std::endian::native> | |||
| inline std::size_t read16(std::byte* data, std::size_t count) noexcept(false) | |||
| { | |||
| if constexpr (Endian == std::endian::little) | |||
| { | |||
| return read16_le(data, count); | |||
| } | |||
| else | |||
| { | |||
| return read16_be(data, count); | |||
| } | |||
| } | |||
| /** | |||
| * Reads 32-bit (double word) data. | |||
| * | |||
| * @tparam Endian Endianness of the read operation. | |||
| * | |||
| * @param data Pointer to data destination. | |||
| * @param count Number of double words to read. | |||
| * | |||
| * @return Number of double words read. | |||
| * | |||
| * @throw deserialize_error Read error. | |||
| */ | |||
| template <std::endian Endian = std::endian::native> | |||
| inline std::size_t read32(std::byte* data, std::size_t count) noexcept(false) | |||
| { | |||
| if constexpr (Endian == std::endian::little) | |||
| { | |||
| return read32_le(data, count); | |||
| } | |||
| else | |||
| { | |||
| return read32_be(data, count); | |||
| } | |||
| } | |||
| /** | |||
| * Reads 64-bit (quad word) data. | |||
| * | |||
| * @tparam Endian Endianness of the read operation. | |||
| * | |||
| * @param data Pointer to data destination. | |||
| * @param count Number of quad words to read. | |||
| * | |||
| * @return Number of quad words read. | |||
| * | |||
| * @throw deserialize_error Read error. | |||
| */ | |||
| template <std::endian Endian = std::endian::native> | |||
| inline std::size_t read64(std::byte* data, std::size_t count) noexcept(false) | |||
| { | |||
| if constexpr (Endian == std::endian::little) | |||
| { | |||
| return read64_le(data, count); | |||
| } | |||
| else | |||
| { | |||
| return read64_be(data, count); | |||
| } | |||
| } | |||
| /** | |||
| * Returns `true` if the end of a file was reached. | |||
| */ | |||
| inline bool eof() const noexcept | |||
| { | |||
| return m_eof; | |||
| } | |||
| /** | |||
| * Returns `true` if an error occured during a read operation, `false` otherwise. | |||
| */ | |||
| inline bool error() const noexcept | |||
| { | |||
| return m_error; | |||
| } | |||
| private: | |||
| template <class T> | |||
| friend class resource_loader; | |||
| deserialize_context(void* handle); | |||
| std::size_t read16_le(std::byte* data, std::size_t count) noexcept(false); | |||
| std::size_t read16_be(std::byte* data, std::size_t count) noexcept(false); | |||
| std::size_t read32_le(std::byte* data, std::size_t count) noexcept(false); | |||
| std::size_t read32_be(std::byte* data, std::size_t count) noexcept(false); | |||
| std::size_t read64_le(std::byte* data, std::size_t count) noexcept(false); | |||
| std::size_t read64_be(std::byte* data, std::size_t count) noexcept(false); | |||
| void* handle; | |||
| bool m_eof; | |||
| bool m_error; | |||
| }; | |||
| #endif // ANTKEEPER_RESOURCES_DESERIALIZE_CONTEXT_HPP | |||
src/resources/string-table.cpp → src/resources/deserialize-error.hpp
View File
+ 125
- 0
src/resources/deserializer.cpp
View File
| @ -0,0 +1,125 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "resources/deserializer.hpp" | |||
| #include <string> | |||
| template <> | |||
| void deserializer<bool>::deserialize(bool& value, deserialize_context& ctx) | |||
| { | |||
| std::uint8_t temp; | |||
| ctx.read8(reinterpret_cast<std::byte*>(&temp), 1); | |||
| value = (temp) ? true : false; | |||
| }; | |||
| template <> | |||
| void deserializer<std::uint8_t>::deserialize(std::uint8_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read8(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::uint16_t>::deserialize(std::uint16_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read16(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::uint32_t>::deserialize(std::uint32_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read32(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::uint64_t>::deserialize(std::uint64_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read64(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::int8_t>::deserialize(std::int8_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read8(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::int16_t>::deserialize(std::int16_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read16(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::int32_t>::deserialize(std::int32_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read32(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::int64_t>::deserialize(std::int64_t& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read64(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<float>::deserialize(float& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read32(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<double>::deserialize(double& value, deserialize_context& ctx) | |||
| { | |||
| ctx.read64(reinterpret_cast<std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void deserializer<std::string>::deserialize(std::string& value, deserialize_context& ctx) | |||
| { | |||
| std::uint64_t length = 0; | |||
| ctx.read64(reinterpret_cast<std::byte*>(&length), 1); | |||
| value.resize(static_cast<std::size_t>(length)); | |||
| ctx.read8(reinterpret_cast<std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
| template <> | |||
| void deserializer<std::u8string>::deserialize(std::u8string& value, deserialize_context& ctx) | |||
| { | |||
| std::uint64_t length = 0; | |||
| ctx.read64(reinterpret_cast<std::byte*>(&length), 1); | |||
| value.resize(static_cast<std::size_t>(length)); | |||
| ctx.read8(reinterpret_cast<std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
| template <> | |||
| void deserializer<std::u16string>::deserialize(std::u16string& value, deserialize_context& ctx) | |||
| { | |||
| std::uint64_t length = 0; | |||
| ctx.read64(reinterpret_cast<std::byte*>(&length), 1); | |||
| value.resize(static_cast<std::size_t>(length)); | |||
| ctx.read16(reinterpret_cast<std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
| template <> | |||
| void deserializer<std::u32string>::deserialize(std::u32string& value, deserialize_context& ctx) | |||
| { | |||
| std::uint64_t length = 0; | |||
| ctx.read64(reinterpret_cast<std::byte*>(&length), 1); | |||
| value.resize(static_cast<std::size_t>(length)); | |||
| ctx.read32(reinterpret_cast<std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
+ 42
- 0
src/resources/deserializer.hpp
View File
| @ -0,0 +1,42 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_RESOURCES_DESERIALIZER_HPP | |||
| #define ANTKEEPER_RESOURCES_DESERIALIZER_HPP | |||
| #include "resources/deserialize-context.hpp" | |||
| /** | |||
| * Specializations of deserializer define the deserialization process for a given type. | |||
| * | |||
| * @tparam T Deserializable type. | |||
| */ | |||
| template <class T> | |||
| struct deserializer | |||
| { | |||
| /** | |||
| * Deserializes a value. | |||
| * | |||
| * @param value Value to deserialize. | |||
| * @param ctx Deserialize context. | |||
| */ | |||
| void deserialize(T& value, deserialize_context& ctx); | |||
| }; | |||
| #endif // ANTKEEPER_RESOURCES_DESERIALIZER_HPP | |||
+ 43
- 0
src/resources/dict-loader.cpp
View File
| @ -0,0 +1,43 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "resources/resource-loader.hpp" | |||
| #include "resources/serializer.hpp" | |||
| #include "resources/deserializer.hpp" | |||
| #include "utility/dict.hpp" | |||
| #include <cstdint> | |||
| #include <physfs.h> | |||
| template <> | |||
| dict<std::uint32_t>* resource_loader<dict<std::uint32_t>>::load(resource_manager* resource_manager, PHYSFS_File* file, const std::filesystem::path& path) | |||
| { | |||
| dict<std::uint32_t>* dict = new ::dict<std::uint32_t>(); | |||
| deserialize_context ctx(file); | |||
| deserializer<::dict<std::uint32_t>>().deserialize(*dict, ctx); | |||
| return dict; | |||
| } | |||
| template <> | |||
| void resource_loader<dict<std::uint32_t>>::save(resource_manager* resource_manager, PHYSFS_File* file, const std::filesystem::path& path, const dict<std::uint32_t>* dict) | |||
| { | |||
| serialize_context ctx(file); | |||
| serializer<::dict<std::uint32_t>>().serialize(*dict, ctx); | |||
| } | |||
+ 32
- 14
src/resources/resource-loader.cpp
View File
+ 31
- 0
src/resources/resource-manager.cpp
View File
+ 2
- 0
src/resources/resource-manager.hpp
View File
+ 144
- 0
src/resources/serialize-context.cpp
View File
| @ -0,0 +1,144 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "resources/serialize-context.hpp" | |||
| #include "resources/serialize-error.hpp" | |||
| #include <physfs.h> | |||
| serialize_context::serialize_context(void* handle): | |||
| handle(handle), | |||
| m_error(false) | |||
| {} | |||
| std::size_t serialize_context::write8(const std::byte* data, std::size_t count) | |||
| { | |||
| const PHYSFS_sint64 status = PHYSFS_writeBytes(reinterpret_cast<PHYSFS_File*>(handle), data, count); | |||
| if (status < 0) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return 0; | |||
| } | |||
| if (status != count) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return static_cast<std::size_t>(count); | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t serialize_context::write16(const std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| const PHYSFS_uint16* data16 = reinterpret_cast<const PHYSFS_uint16*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if constexpr (serialize_context::endian == std::endian::little) | |||
| { | |||
| if (!PHYSFS_writeULE16(file, *data16)) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| } | |||
| else | |||
| { | |||
| if (!PHYSFS_writeUBE16(file, *data16)) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| } | |||
| ++data16; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t serialize_context::write32(const std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| const PHYSFS_uint32* data32 = reinterpret_cast<const PHYSFS_uint32*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if constexpr (serialize_context::endian == std::endian::little) | |||
| { | |||
| if (!PHYSFS_writeULE32(file, *data32)) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| } | |||
| else | |||
| { | |||
| if (!PHYSFS_writeUBE32(file, *data32)) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| } | |||
| ++data32; | |||
| } | |||
| return count; | |||
| } | |||
| std::size_t serialize_context::write64(const std::byte* data, std::size_t count) | |||
| { | |||
| PHYSFS_File* file = reinterpret_cast<PHYSFS_File*>(handle); | |||
| const PHYSFS_uint64* data64 = reinterpret_cast<const PHYSFS_uint64*>(data); | |||
| for (std::size_t i = 0; i < count; ++i) | |||
| { | |||
| if constexpr (serialize_context::endian == std::endian::little) | |||
| { | |||
| if (!PHYSFS_writeULE64(file, *data64)) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| } | |||
| else | |||
| { | |||
| if (!PHYSFS_writeUBE64(file, *data64)) | |||
| { | |||
| m_error = true; | |||
| throw serialize_error(PHYSFS_getLastError()); | |||
| //return i; | |||
| } | |||
| } | |||
| ++data64; | |||
| } | |||
| return count; | |||
| } | |||
+ 100
- 0
src/resources/serialize-context.hpp
View File
| @ -0,0 +1,100 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_RESOURCES_SERIALIZE_CONTEXT_HPP | |||
| #define ANTKEEPER_RESOURCES_SERIALIZE_CONTEXT_HPP | |||
| #include <cstddef> | |||
| #include <bit> | |||
| /** | |||
| * Provides access to a serialization state. | |||
| */ | |||
| struct serialize_context | |||
| { | |||
| public: | |||
| static inline constexpr std::endian endian = std::endian::little; | |||
| /** | |||
| * Writes 8-bit (byte) data. | |||
| * | |||
| * @param data Pointer to data source. | |||
| * @param count Number of bytes to write. | |||
| * | |||
| * @return Number of bytes written. | |||
| * | |||
| * @throw serialize_error Write error. | |||
| */ | |||
| std::size_t write8(const std::byte* data, std::size_t count) noexcept(false); | |||
| /** | |||
| * Writes 16-bit (word) data. | |||
| * | |||
| * @param data Pointer to data source. | |||
| * @param count Number of words to write. | |||
| * | |||
| * @return Number of words written. | |||
| * | |||
| * @throw serialize_error Write error. | |||
| */ | |||
| std::size_t write16(const std::byte* data, std::size_t count) noexcept(false); | |||
| /** | |||
| * Writes 32-bit (double word) data. | |||
| * | |||
| * @param data Pointer to data source. | |||
| * @param count Number of double words to write. | |||
| * | |||
| * @return Number of double words written. | |||
| * | |||
| * @throw serialize_error Write error. | |||
| */ | |||
| std::size_t write32(const std::byte* data, std::size_t count) noexcept(false); | |||
| /** | |||
| * Writes 64-bit (quad word) data. | |||
| * | |||
| * @param data Pointer to data source. | |||
| * @param count Number of quad words to write. | |||
| * | |||
| * @return Number of quad words written. | |||
| * | |||
| * @throw serialize_error Write error. | |||
| */ | |||
| std::size_t write64(const std::byte* data, std::size_t count) noexcept(false); | |||
| /** | |||
| * Returns `true` if an error occured during a write operation, `false` otherwise. | |||
| */ | |||
| inline bool error() const noexcept | |||
| { | |||
| return m_error; | |||
| } | |||
| private: | |||
| template <class T> | |||
| friend class resource_loader; | |||
| serialize_context(void* handle); | |||
| void* handle; | |||
| bool m_error; | |||
| }; | |||
| #endif // ANTKEEPER_RESOURCES_SERIALIZE_CONTEXT_HPP | |||
+ 33
- 0
src/resources/serialize-error.hpp
View File
| @ -0,0 +1,33 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_RESOURCES_SERIALIZE_ERROR_HPP | |||
| #define ANTKEEPER_RESOURCES_SERIALIZE_ERROR_HPP | |||
| #include <stdexcept> | |||
| /** | |||
| * An exception of this type is thrown when an error occurs during serialization. | |||
| */ | |||
| class serialize_error: public std::runtime_error | |||
| { | |||
| using std::runtime_error::runtime_error; | |||
| }; | |||
| #endif // ANTKEEPER_RESOURCES_SERIALIZE_ERROR_HPP | |||
+ 120
- 0
src/resources/serializer.cpp
View File
| @ -0,0 +1,120 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "resources/serializer.hpp" | |||
| #include <string> | |||
| template <> | |||
| void serializer<bool>::serialize(const bool& value, serialize_context& ctx) | |||
| { | |||
| const std::uint8_t temp = (value) ? 1 : 0; | |||
| ctx.write8(reinterpret_cast<const std::byte*>(&temp), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::uint8_t>::serialize(const std::uint8_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write8(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::uint16_t>::serialize(const std::uint16_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write16(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::uint32_t>::serialize(const std::uint32_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write32(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::uint64_t>::serialize(const std::uint64_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::int8_t>::serialize(const std::int8_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write8(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::int16_t>::serialize(const std::int16_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write16(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::int32_t>::serialize(const std::int32_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write32(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::int64_t>::serialize(const std::int64_t& value, serialize_context& ctx) | |||
| { | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<float>::serialize(const float& value, serialize_context& ctx) | |||
| { | |||
| ctx.write32(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<double>::serialize(const double& value, serialize_context& ctx) | |||
| { | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&value), 1); | |||
| }; | |||
| template <> | |||
| void serializer<std::string>::serialize(const std::string& value, serialize_context& ctx) | |||
| { | |||
| const std::uint64_t length = static_cast<std::uint64_t>(value.length()); | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&length), 1); | |||
| ctx.write8(reinterpret_cast<const std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
| template <> | |||
| void serializer<std::u8string>::serialize(const std::u8string& value, serialize_context& ctx) | |||
| { | |||
| const std::uint64_t length = static_cast<std::uint64_t>(value.length()); | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&length), 1); | |||
| ctx.write8(reinterpret_cast<const std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
| template <> | |||
| void serializer<std::u16string>::serialize(const std::u16string& value, serialize_context& ctx) | |||
| { | |||
| const std::uint64_t length = static_cast<std::uint64_t>(value.length()); | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&length), 1); | |||
| ctx.write16(reinterpret_cast<const std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
| template <> | |||
| void serializer<std::u32string>::serialize(const std::u32string& value, serialize_context& ctx) | |||
| { | |||
| const std::uint64_t length = static_cast<std::uint64_t>(value.length()); | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&length), 1); | |||
| ctx.write32(reinterpret_cast<const std::byte*>(value.data()), static_cast<std::size_t>(length)); | |||
| }; | |||
+ 42
- 0
src/resources/serializer.hpp
View File
| @ -0,0 +1,42 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_RESOURCES_SERIALIZER_HPP | |||
| #define ANTKEEPER_RESOURCES_SERIALIZER_HPP | |||
| #include "resources/serialize-context.hpp" | |||
| /** | |||
| * Specializations of serializer define the serialization process for a given type. | |||
| * | |||
| * @tparam T Serializable type. | |||
| */ | |||
| template <class T> | |||
| struct serializer | |||
| { | |||
| /** | |||
| * Serializes a value. | |||
| * | |||
| * @param value Value to serialize. | |||
| * @param ctx Serialize context. | |||
| */ | |||
| void serialize(const T& value, serialize_context& ctx); | |||
| }; | |||
| #endif // ANTKEEPER_RESOURCES_SERIALIZER_HPP | |||
+ 43
- 101
src/resources/string-table-loader.cpp
View File
+ 168
- 0
src/utility/dict.cpp
View File
| @ -0,0 +1,168 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #include "utility/dict.hpp" | |||
| #include "resources/serializer.hpp" | |||
| #include "resources/serialize-error.hpp" | |||
| #include "resources/deserializer.hpp" | |||
| #include "resources/deserialize-error.hpp" | |||
| #include "utility/hash/fnv1a.hpp" | |||
| #include <cstdint> | |||
| #include <string> | |||
| #include <tuple> | |||
| #include <typeindex> | |||
| #include <unordered_map> | |||
| using namespace hash::literals; | |||
| template <class T> | |||
| static void serialize_any(const std::any& any, serialize_context& ctx) | |||
| { | |||
| serializer<T>().serialize(std::any_cast<T>(any), ctx); | |||
| } | |||
| template <class T> | |||
| static void deserialize_any(std::any& any, deserialize_context& ctx) | |||
| { | |||
| T value; | |||
| deserializer<T>().deserialize(value, ctx); | |||
| any = std::move(value); | |||
| } | |||
| /** | |||
| * Serializes a dict with an unsigned 32-bit key. | |||
| * | |||
| * @throw serialize_error Write error. | |||
| * @throw serialize_error Unsupported dict value type. | |||
| */ | |||
| template <> | |||
| void serializer<dict<std::uint32_t>>::serialize(const dict<std::uint32_t>& dict, serialize_context& ctx) | |||
| { | |||
| // Map type indices to tuples containing a type hash and serialize function pointer | |||
| static const std::unordered_map | |||
| < | |||
| std::type_index, | |||
| std::tuple | |||
| < | |||
| std::uint32_t, | |||
| void (*)(const std::any&, serialize_context&) | |||
| > | |||
| > type_map | |||
| { | |||
| {std::type_index(typeid(bool)), {"bool"_fnv1a32, &serialize_any<bool>}}, | |||
| {std::type_index(typeid(std::uint8_t)), {"uint8"_fnv1a32, &serialize_any<std::uint8_t>}}, | |||
| {std::type_index(typeid(std::uint16_t)), {"uint16"_fnv1a32, &serialize_any<std::uint16_t>}}, | |||
| {std::type_index(typeid(std::uint32_t)), {"uint32"_fnv1a32, &serialize_any<std::uint32_t>}}, | |||
| {std::type_index(typeid(std::uint64_t)), {"uint64"_fnv1a32, &serialize_any<std::uint64_t>}}, | |||
| {std::type_index(typeid(std::int8_t)), {"int8"_fnv1a32, &serialize_any<std::int8_t>}}, | |||
| {std::type_index(typeid(std::int16_t)), {"int16"_fnv1a32, &serialize_any<std::int16_t>}}, | |||
| {std::type_index(typeid(std::int32_t)), {"int32"_fnv1a32, &serialize_any<std::int32_t>}}, | |||
| {std::type_index(typeid(std::int64_t)), {"int64"_fnv1a32, &serialize_any<std::int64_t>}}, | |||
| {std::type_index(typeid(float)), {"float"_fnv1a32, &serialize_any<float>}}, | |||
| {std::type_index(typeid(double)), {"double"_fnv1a32, &serialize_any<double>}}, | |||
| {std::type_index(typeid(std::string)), {"string"_fnv1a32, &serialize_any<std::string>}}, | |||
| {std::type_index(typeid(std::u8string)), {"u8string"_fnv1a32, &serialize_any<std::u8string>}}, | |||
| {std::type_index(typeid(std::u16string)), {"u16string"_fnv1a32, &serialize_any<std::u16string>}}, | |||
| {std::type_index(typeid(std::u32string)), {"u32string"_fnv1a32, &serialize_any<std::u32string>}} | |||
| }; | |||
| // Write dict size | |||
| std::uint64_t size = static_cast<std::uint64_t>(dict.size()); | |||
| ctx.write64(reinterpret_cast<const std::byte*>(&size), 1); | |||
| // Write dict entries | |||
| for (const auto& [key, value]: dict) | |||
| { | |||
| if (auto i = type_map.find(value.type()); i != type_map.end()) | |||
| { | |||
| const auto& [type_hash, type_serializer] = i->second; | |||
| // Write entry type hash and key | |||
| ctx.write32(reinterpret_cast<const std::byte*>(&type_hash), 1); | |||
| ctx.write32(reinterpret_cast<const std::byte*>(&key), 1); | |||
| // Serialize entry value | |||
| type_serializer(value, ctx); | |||
| } | |||
| else | |||
| { | |||
| throw serialize_error("Unsupported dict value type"); | |||
| } | |||
| } | |||
| }; | |||
| /** | |||
| * Deserializes a dict with an unsigned 32-bit key. | |||
| * | |||
| * @throw deserialize_error Write error. | |||
| * @throw deserialize_error Unsupported dict value type. | |||
| */ | |||
| template <> | |||
| void deserializer<dict<std::uint32_t>>::deserialize(dict<std::uint32_t>& dict, deserialize_context& ctx) | |||
| { | |||
| // Map type hashes to deserialize function pointers | |||
| static const std::unordered_map | |||
| < | |||
| std::uint32_t, | |||
| void (*)(std::any&, deserialize_context&) | |||
| > type_map | |||
| { | |||
| {"bool"_fnv1a32, &deserialize_any<bool>}, | |||
| {"uint8"_fnv1a32, &deserialize_any<std::uint8_t>}, | |||
| {"uint16"_fnv1a32, &deserialize_any<std::uint16_t>}, | |||
| {"uint32"_fnv1a32, &deserialize_any<std::uint32_t>}, | |||
| {"uint64"_fnv1a32, &deserialize_any<std::uint64_t>}, | |||
| {"int8"_fnv1a32, &deserialize_any<std::int8_t>}, | |||
| {"int16"_fnv1a32, &deserialize_any<std::int16_t>}, | |||
| {"int32"_fnv1a32, &deserialize_any<std::int32_t>}, | |||
| {"int64"_fnv1a32, &deserialize_any<std::int64_t>}, | |||
| {"float"_fnv1a32, &deserialize_any<float>}, | |||
| {"double"_fnv1a32, &deserialize_any<double>}, | |||
| {"string"_fnv1a32, &deserialize_any<std::string>}, | |||
| {"u8string"_fnv1a32, &deserialize_any<std::u8string>}, | |||
| {"u16string"_fnv1a32, &deserialize_any<std::u16string>}, | |||
| {"u32string"_fnv1a32, &deserialize_any<std::u32string>} | |||
| }; | |||
| // Read dict size | |||
| std::uint64_t size = 0; | |||
| ctx.read64(reinterpret_cast<std::byte*>(&size), 1); | |||
| // Read dict entries | |||
| for (std::size_t i = 0; i < size; ++i) | |||
| { | |||
| // Read entry type hash | |||
| std::uint32_t type_hash = 0; | |||
| ctx.read32(reinterpret_cast<std::byte*>(&type_hash), 1); | |||
| if (auto i = type_map.find(type_hash); i != type_map.end()) | |||
| { | |||
| // Read entry key | |||
| std::uint32_t key = 0; | |||
| ctx.read32(reinterpret_cast<std::byte*>(&key), 1); | |||
| // Deserialize entry value | |||
| i->second(dict[key], ctx); | |||
| } | |||
| else | |||
| { | |||
| throw deserialize_error("Unsupported dict value type"); | |||
| } | |||
| } | |||
| }; | |||
+ 34
- 0
src/utility/dict.hpp
View File
| @ -0,0 +1,34 @@ | |||
| /* | |||
| * Copyright (C) 2023 Christopher J. Howard | |||
| * | |||
| * This file is part of Antkeeper source code. | |||
| * | |||
| * Antkeeper source code 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, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * Antkeeper source code is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; 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 Antkeeper source code. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #ifndef ANTKEEPER_UTILITY_DICT_HPP | |||
| #define ANTKEEPER_UTILITY_DICT_HPP | |||
| #include <any> | |||
| #include <unordered_map> | |||
| /** | |||
| * Unordered dictionary type. | |||
| * | |||
| * @tparam Key Key type. | |||
| */ | |||
| template <class Key> | |||
| using dict = std::unordered_map<Key, std::any>; | |||
| #endif // ANTKEEPER_UTILITY_DICT_HPP | |||