Skip to content

Commit c49b55f

Browse files
FlyAndNotDownFlyAndNotDown
authored
Merge pull request #385 from FlyAndNotDown/master
Feat: Misc Update
2 parents 49e4988 + 1e826e7 commit c49b55f

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

85 files changed

+1479
-440
lines changed

‎.github/workflows/build.yml

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -35,15 +35,15 @@ jobs:
3535
if: runner.os == 'macOS'
3636

3737
- name: Checkout Repo
38-
uses: actions/checkout@v2
38+
uses: actions/checkout@v4
3939

4040
- name: Setup cmake
4141
uses: jwlawson/actions-setup-cmake@v2
4242
with:
4343
cmake-version: ${{env.CMAKE_VERSION}}
4444

4545
- name: Update Cache Files
46-
uses: actions/cache@v2
46+
uses: actions/cache@v4
4747
with:
4848
path: ${{github.workspace}}/ThirdParty/Zip
4949
key: ${{runner.os}}-3rd-zip

‎Engine/Source/Common/Include/Common/File.h

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,13 @@
66

77
#include <string>
88

9+
#include <rapidjson/document.h>
10+
911
namespace Common {
1012
class FileUtils {
1113
public:
12-
static std::string ReadTextFile(const std::string& fileName);
14+
static std::string ReadTextFile(const std::string& inFileName);
15+
static rapidjson::Document ReadJsonFile(const std::string& inFileName);
16+
static void WriteJsonFile(const std::string& inFileName, const rapidjson::Document& inJsonDocument, bool inPretty = true);
1317
};
1418
}

‎Engine/Source/Common/Include/Common/FileSystem.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
#pragma once
66

77
#include <filesystem>
8+
#include <functional>
89

910
namespace Common {
1011
class Path {

‎Engine/Source/Common/Include/Common/Serialization.h

Lines changed: 98 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -15,18 +15,16 @@
1515
#include <unordered_map>
1616
#include <set>
1717
#include <map>
18+
#include <variant>
1819

1920
#include <rapidjson/document.h>
20-
#include <rapidjson/filereadstream.h>
21-
#include <rapidjson/filewritestream.h>
22-
#include <rapidjson/writer.h>
23-
#include <rapidjson/prettywriter.h>
2421

2522
#include <Common/Utility.h>
2623
#include <Common/Debug.h>
2724
#include <Common/Hash.h>
2825
#include <Common/String.h>
2926
#include <Common/FileSystem.h>
27+
#include <Common/File.h>
3028

3129
namespace Common {
3230
class BinarySerializeStream {
@@ -476,39 +474,15 @@ namespace Common {
476474

477475
template <typename T> void JsonSerializeToFile(const std::string& inFile, const T& inValue, bool inPretty)
478476
{
479-
Common::Path parentPath = Common::Path(inFile).Parent();
480-
if (!parentPath.Exists()) {
481-
parentPath.MakeDir();
482-
}
483-
484477
rapidjson::Document document;
485478
JsonSerialize<T>(document, document.GetAllocator(), inValue);
486-
487-
char buffer[65536];
488-
std::FILE* file = fopen(inFile.c_str(), "wb");
489-
rapidjson::FileWriteStream stream(file, buffer, sizeof(buffer));
490-
491-
if (inPretty) {
492-
rapidjson::PrettyWriter writer(stream);
493-
document.Accept(writer);
494-
} else {
495-
rapidjson::Writer writer(stream);
496-
document.Accept(writer);
497-
}
498-
(void) fclose(file);
479+
FileUtils::WriteJsonFile(inFile, document, inPretty);
499480
}
500481

501482
template <typename T> void JsonDeserializeFromFile(const std::string& inFile, T& outValue)
502483
{
503-
char buffer[65536];
504-
std::FILE* file = fopen(inFile.c_str(), "rb");
505-
rapidjson::FileReadStream stream(file, buffer, sizeof(buffer));
506-
507-
rapidjson::Document document;
508-
document.ParseStream(stream);
509-
484+
const rapidjson::Document document = FileUtils::ReadJsonFile(inFile);
510485
JsonDeserialize<T>(document, outValue);
511-
(void) fclose(file);
512486
}
513487

514488
template <Serializable T>
@@ -982,21 +956,21 @@ namespace Common {
982956
template <size_t... I>
983957
static size_t SerializeInternal(BinarySerializeStream& stream, const std::tuple<T...>& value, std::index_sequence<I...>)
984958
{
985-
size_t result = 0;
959+
size_t serialized = 0;
986960
std::initializer_list<int> { ([&]() -> void {
987-
result += Serializer<T>::Serialize(stream, std::get<I>(value));
961+
serialized += Serializer<T>::Serialize(stream, std::get<I>(value));
988962
}(), 0)... };
989-
return result;
963+
return serialized;
990964
}
991965

992966
template <size_t... I>
993967
static size_t DeserializeInternal(BinaryDeserializeStream& stream, std::tuple<T...>& value, std::index_sequence<I...>)
994968
{
995-
size_t result = 0;
969+
size_t deserialized = 0;
996970
std::initializer_list<int> { ([&]() -> void {
997-
result += Serializer<T>::Deserialize(stream, std::get<I>(value));
971+
deserialized += Serializer<T>::Deserialize(stream, std::get<I>(value));
998972
}(), 0)... };
999-
return result;
973+
return deserialized;
1000974
}
1001975

1002976
static size_t Serialize(BinarySerializeStream& stream, const std::tuple<T...>& value)
@@ -1035,6 +1009,51 @@ namespace Common {
10351009
}
10361010
};
10371011

1012+
template <typename... T> struct VariantTypeId {};
1013+
template <typename T> struct VariantTypeId<T> { static constexpr size_t value = HashUtils::StrCrc32("std::variant"); };
1014+
template <typename T, typename... T2> struct VariantTypeId<T, T2...> { static constexpr size_t value = Serializer<T>::typeId + VariantTypeId<T2...>::value; };
1015+
1016+
template <Serializable... T>
1017+
struct Serializer<std::variant<T...>> {
1018+
static constexpr size_t typeId = VariantTypeId<T...>::value;
1019+
1020+
static size_t Serialize(BinarySerializeStream& stream, const std::variant<T...>& value)
1021+
{
1022+
size_t serialized = 0;
1023+
serialized += Serializer<uint64_t>::Serialize(stream, value.index());
1024+
std::visit([&](auto&& v) -> void { // NOLINT
1025+
serialized += Serializer<std::decay_t<decltype(v)>>::Serialize(stream, v);
1026+
}, value);
1027+
return serialized;
1028+
}
1029+
1030+
template <size_t... I>
1031+
static size_t DeserializeInternal(BinaryDeserializeStream& stream, std::variant<T...>& value, size_t aspectIndex, std::index_sequence<I...>)
1032+
{
1033+
size_t deserialized = 0;
1034+
(void) std::initializer_list<int> { ([&]() -> void {
1035+
if (I != aspectIndex) {
1036+
return;
1037+
}
1038+
1039+
T tempValue;
1040+
deserialized += Serializer<T>::Deserialize(stream, tempValue);
1041+
value = std::move(tempValue);
1042+
}(), 0)... };
1043+
return deserialized;
1044+
}
1045+
1046+
static size_t Deserialize(BinaryDeserializeStream& stream, std::variant<T...>& value)
1047+
{
1048+
size_t deserialized = 0;
1049+
1050+
uint64_t index;
1051+
deserialized += Serializer<uint64_t>::Deserialize(stream, index);
1052+
deserialized += DeserializeInternal(stream, value, index, std::make_index_sequence<sizeof...(T)> {});
1053+
return deserialized;
1054+
}
1055+
};
1056+
10381057
template <>
10391058
struct JsonSerializer<int8_t> {
10401059
static void JsonSerialize(rapidjson::Value& outJsonValue, rapidjson::Document::AllocatorType& inAllocator, const int8_t& inValue)
@@ -1528,4 +1547,47 @@ namespace Common {
15281547
JsonDeserializeInternal(inJsonValue, outValue, std::make_index_sequence<sizeof...(T)>());
15291548
}
15301549
};
1550+
1551+
template <JsonSerializable... T>
1552+
struct JsonSerializer<std::variant<T...>> {
1553+
static void JsonSerialize(rapidjson::Value& outJsonValue, rapidjson::Document::AllocatorType& inAllocator, const std::variant<T...>& inValue)
1554+
{
1555+
rapidjson::Value typeValue;
1556+
JsonSerializer<uint64_t>::JsonSerialize(typeValue, inAllocator, inValue.index());
1557+
1558+
rapidjson::Value contentValue;
1559+
std::visit([&](auto&& v) -> void {
1560+
JsonSerializer<std::decay_t<decltype(v)>>::JsonSerialize(contentValue, inAllocator, v);
1561+
}, inValue);
1562+
1563+
outJsonValue.SetObject();
1564+
outJsonValue.AddMember("type", typeValue, inAllocator);
1565+
outJsonValue.AddMember("content", contentValue, inAllocator);
1566+
}
1567+
1568+
template <size_t... I>
1569+
static void JsonDeserializeInternal(const rapidjson::Value& inContentJsonValue, std::variant<T...>& outValue, size_t inAspectIndex, std::index_sequence<I...>)
1570+
{
1571+
(void) std::initializer_list<int> { ([&]() -> void {
1572+
if (I != inAspectIndex) {
1573+
return;
1574+
}
1575+
1576+
T temp;
1577+
JsonSerializer<T>::JsonDeserialize(inContentJsonValue, temp);
1578+
outValue = std::move(temp);
1579+
}(), 0)... };
1580+
}
1581+
1582+
static void JsonDeserialize(const rapidjson::Value& inJsonValue, std::variant<T...>& outValue)
1583+
{
1584+
if (!inJsonValue.HasMember("type") || !inJsonValue.HasMember("content")) {
1585+
return;
1586+
}
1587+
1588+
uint64_t aspectIndex;
1589+
JsonSerializer<uint64_t>::JsonDeserialize(inJsonValue["type"], aspectIndex);
1590+
JsonDeserializeInternal(inJsonValue["content"], outValue, aspectIndex, std::make_index_sequence<sizeof...(T)> {});
1591+
}
1592+
};
15311593
}

‎Engine/Source/Common/Include/Common/Time.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,8 @@ namespace Common {
1818

1919
Time ToTime() const;
2020
AccurateTime ToAccurateTime() const;
21-
float ToSeconds() const;
22-
float ToMilliseconds() const;
21+
double ToSeconds() const;
22+
double ToMilliseconds() const;
2323
uint64_t ToMicroseconds() const;
2424
const std::chrono::system_clock::time_point& GetNative() const;
2525

‎Engine/Source/Common/Src/File.cpp

Lines changed: 42 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,16 +3,23 @@
33
//
44

55
#include <fstream>
6+
#include <cstdio>
7+
8+
#include <rapidjson/filereadstream.h>
9+
#include <rapidjson/filewritestream.h>
10+
#include <rapidjson/writer.h>
11+
#include <rapidjson/prettywriter.h>
612

713
#include <Common/File.h>
814
#include <Common/Debug.h>
15+
#include <Common/FileSystem.h>
916

1017
namespace Common {
11-
std::string FileUtils::ReadTextFile(const std::string& fileName)
18+
std::string FileUtils::ReadTextFile(const std::string& inFileName)
1219
{
1320
std::string result;
1421
{
15-
std::ifstream file(fileName, std::ios::ate | std::ios::binary);
22+
std::ifstream file(inFileName, std::ios::ate | std::ios::binary);
1623
Assert(file.is_open());
1724
const size_t size = file.tellg();
1825
result.resize(size);
@@ -22,4 +29,37 @@ namespace Common {
2229
}
2330
return result;
2431
}
32+
33+
rapidjson::Document FileUtils::ReadJsonFile(const std::string& inFileName)
34+
{
35+
char buffer[65536];
36+
std::FILE* file = fopen(inFileName.c_str(), "rb"); // NOLINT
37+
rapidjson::FileReadStream stream(file, buffer, sizeof(buffer));
38+
39+
rapidjson::Document document;
40+
document.ParseStream(stream);
41+
(void) fclose(file);
42+
return document;
43+
}
44+
45+
void FileUtils::WriteJsonFile(const std::string& inFileName, const rapidjson::Document& inJsonDocument, bool inPretty)
46+
{
47+
Common::Path parentPath = Common::Path(inFileName).Parent();
48+
if (!parentPath.Exists()) {
49+
parentPath.MakeDir();
50+
}
51+
52+
char buffer[65536];
53+
std::FILE* file = fopen(inFileName.c_str(), "wb"); // NOLINT
54+
rapidjson::FileWriteStream stream(file, buffer, sizeof(buffer));
55+
56+
if (inPretty) {
57+
rapidjson::PrettyWriter writer(stream);
58+
inJsonDocument.Accept(writer);
59+
} else {
60+
rapidjson::Writer writer(stream);
61+
inJsonDocument.Accept(writer);
62+
}
63+
(void) fclose(file);
64+
}
2565
}

‎Engine/Source/Common/Src/Time.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -45,14 +45,14 @@ namespace Common {
4545
return AccurateTime { *this };
4646
}
4747

48-
float TimePoint::ToSeconds() const
48+
double TimePoint::ToSeconds() const
4949
{
50-
return ToMilliseconds() / 1000.0f;
50+
return ToMilliseconds() / 1000.0;
5151
}
5252

53-
float TimePoint::ToMilliseconds() const
53+
double TimePoint::ToMilliseconds() const
5454
{
55-
return static_cast<float>(ToMicroseconds()) / 1000.0f;
55+
return static_cast<double>(ToMicroseconds()) / 1000.0;
5656
}
5757

5858
uint64_t TimePoint::ToMicroseconds() const

‎Engine/Source/Common/Test/SerializationTest.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,6 @@
22
// Created by johnk on 2023/7/13.
33
//
44

5-
#include <filesystem>
6-
75
#include <Common/Memory.h>
86
#include <SerializationTest.h>
97

@@ -76,6 +74,7 @@ TEST(SerializationTest, TypedSerializationTest)
7674
PerformTypedSerializationTest<std::unordered_map<int, bool>>({ { 1, false }, { 2, true } });
7775
PerformTypedSerializationTest<std::map<int, bool>>({ { 1, false }, { 2, true } });
7876
PerformTypedSerializationTest<std::tuple<int, bool, int>>({ 1, true, 2 });
77+
PerformTypedSerializationTest<std::variant<int, bool, float>>({ true });
7978
}
8079

8180
TEST(SerializationTest, TypedSerializationWithFileTest)
@@ -107,6 +106,7 @@ TEST(SerializationTest, TypedSerializationWithFileTest)
107106
PerformTypeSerializationWithFileTest<std::unordered_map<int, bool>>(fileName, { { 1, false }, { 2, true } });
108107
PerformTypeSerializationWithFileTest<std::map<int, bool>>(fileName, { { 1, false }, { 2, true } });
109108
PerformTypeSerializationWithFileTest<std::tuple<int, bool, int>>(fileName, { 1, true, 2 });
109+
PerformTypeSerializationWithFileTest<std::variant<int, bool, float>>(fileName, { true });
110110
}
111111

112112
TEST(SerializationTest, JsonSerializationTest)
@@ -137,6 +137,7 @@ TEST(SerializationTest, JsonSerializationTest)
137137
PerformJsonSerializationTest<std::map<int, bool>>({ { 1, false }, { 2, true } }, R"([{"key":1,"value":false},{"key":2,"value":true}])");
138138
PerformJsonSerializationTest<std::map<std::string, int>>({ { "1", 1 }, { "2", 2 } }, R"([{"key":"1","value":1},{"key":"2","value":2}])");
139139
PerformJsonSerializationTest<std::tuple<int, bool, int>>({ 1, true, 2 }, R"({"0":1,"1":true,"2":2})");
140+
PerformJsonSerializationTest<std::variant<int, bool, float>>({ true }, R"({"type":1,"content":true})");
140141
}
141142

142143
TEST(SerializationTest, JsonSerializationWithFileTest)
@@ -169,4 +170,5 @@ TEST(SerializationTest, JsonSerializationWithFileTest)
169170
PerformJsonSerializationWithFileTest<std::map<int, bool>>(fileName, { { 1, false }, { 2, true } });
170171
PerformJsonSerializationWithFileTest<std::map<std::string, int>>(fileName, { { "1", 1 }, { "2", 2 } });
171172
PerformJsonSerializationWithFileTest<std::tuple<int, bool, int>>(fileName, { 1, true, 2 });
173+
PerformTypeSerializationWithFileTest<std::variant<int, bool, float>>(fileName, { true });
172174
}

0 commit comments

Comments
 (0)