Util: Add helper Util::Json to Util::JSON::Value

src/config.cpp

@@ -13,7 +13,7 @@
 #include <vector>
 
 #include "config.h"
-#include "util/json/value.h"
+#include "util/json/json.h"
 
 Config::Config(s)
 	: m_workingDirectory(std::filesystem::current_path())
@@ -51,7 +51,7 @@ void Config::parseConfigFile()
 		return;
 	}
 
-	Json::Value json;
+	Util::Json json;
 
 	std::ifstream file(m_config);
 	if (!file.is_open()) {
@@ -72,17 +72,17 @@ void Config::parseConfigFile()
 
 // -----------------------------------------
 
-void toJson(Json::Value& json, const Settings& settings)
+void toJson(Util::Json& json, const Settings& settings)
 {
-	json = Json::Value {
+	json = Util::Json {
 		{ "ignorePatterns", settings.ignorePatterns },
 		{ "systemPatterns", settings.systemPatterns }
 	};
 }
 
-void fromJson(const Json::Value& json, Settings& settings)
+void fromJson(const Util::Json& json, Settings& settings)
 {
-	assert(json.type() == Json::Value::Type::Object);
+	assert(json.type() == Util::Json::Type::Object);
 
 	if (json.exists("ignorePatterns")) {
 		json.at("ignorePatterns").getTo(settings.ignorePatterns);

src/config.h

@@ -13,7 +13,7 @@
 #include <vector>
 
 #include "util/singleton.h"
-#include "util/json/value.h"
+#include "util/json/json.h"
 
 struct Settings {
 	std::vector<std::string> ignorePatterns {
@@ -65,7 +65,7 @@ private:
 
 // Json arbitrary type conversion functions
 
-void toJson(Json::Value& object, const Settings& settings);
-void fromJson(const Json::Value& object, Settings& settings);
+void toJson(Util::Json& object, const Settings& settings);
+void fromJson(const Util::Json& object, Settings& settings);
 
 #endif // CONFIG_H

src/util/json/array.cpp

@@ -7,7 +7,7 @@
 #include "util/json/array.h"
 #include "util/json/value.h"
 
-namespace Json {
+namespace Util::JSON {
 
 void Array::emplace_back(Value element)
 {
@@ -23,4 +23,4 @@ Value& Array::operator[](size_t index)
 	return m_elements[index];
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/array.h

@@ -4,15 +4,15 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_ARRAY_H
-#define JSON_ARRAY_H
+#ifndef UTIL_JSON_ARRAY_H
+#define UTIL_JSON_ARRAY_H
 
 #include <utility> // move
 #include <vector>
 
 #include "util/json/parser.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Value;
 
@@ -54,6 +54,6 @@ private:
 	std::vector<Value> m_elements;
 };
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_ARRAY_H
+#endif // UTIL_JSON_ARRAY_H

src/util/json/fromjson.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_FROM_JSON_H
-#define JSON_FROM_JSON_H
+#ifndef UTIL_JSON_FROM_JSON_H
+#define UTIL_JSON_FROM_JSON_H
 
 #include <algorithm> // transform
 #include <cassert>   // assert
@@ -20,7 +20,7 @@
 #include "util/json/object.h"
 #include "util/meta/odr.h"
 
-namespace Json {
+namespace Util::JSON {
 
 namespace Detail {
 
@@ -116,9 +116,9 @@ namespace {
 constexpr const auto& fromJson = Util::Detail::staticConst<Detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
 } // namespace
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_FROM_JSON_H
+#endif // UTIL_JSON_FROM_JSON_H
 
 // Customization Points
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

src/util/json/job.cpp

@@ -13,7 +13,7 @@
 #include "util/json/parser.h"
 #include "util/json/value.h"
 
-namespace Json {
+namespace Util::JSON {
 
 Job::Job(std::string_view input)
 	: m_input(input)
@@ -111,4 +111,4 @@ void Job::printErrorLine(Token token, const char* message)
 	        std::string(line.length() - token.column, '~').c_str());
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/job.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_JOB_H
-#define JSON_JOB_H
+#ifndef UTIL_JSON_JOB_H
+#define UTIL_JSON_JOB_H
 
 #include <cstddef> // size_t
 #include <string_view>
@@ -13,7 +13,7 @@
 
 #include "util/json/lexer.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Value;
 
@@ -48,6 +48,6 @@ private:
 	std::vector<Token> m_tokens;
 };
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_JOB_H
+#endif // UTIL_JSON_JOB_H

src/util/json/json.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2022 Riyyi
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef UTIL_JSON_JSON_H
+#define UTIL_JSON_JSON_H
+
+#include "util/json/value.h"
+
+namespace Util {
+
+using Json = Util::JSON::Value;
+
+} // namespace Util
+
+#endif // UTIL_JSON_JSON_H

src/util/json/lexer.cpp

@@ -10,7 +10,7 @@
 #include "util/json/job.h"
 #include "util/json/lexer.h"
 
-namespace Json {
+namespace Util::JSON {
 
 Lexer::Lexer(Job* job)
 	: GenericLexer(job->input())
@@ -214,4 +214,4 @@ bool Lexer::consumeLiteral()
 	return consumeNumberOrLiteral(Token::Type::Literal);
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/lexer.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_LEXER_H
-#define JSON_LEXER_H
+#ifndef UTIL_JSON_LEXER_H
+#define UTIL_JSON_LEXER_H
 
 // The JavaScript Object Notation (JSON) Data Interchange Format
 // https://www.rfc-editor.org/rfc/pdfrfc/rfc8259.txt.pdf
@@ -16,7 +16,7 @@
 
 #include "util/genericlexer.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Job;
 
@@ -62,6 +62,6 @@ private:
 	std::vector<Token>* m_tokens { nullptr };
 };
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_LEXER_H
+#endif // UTIL_JSON_LEXER_H

src/util/json/object.cpp

@@ -7,7 +7,7 @@
 #include "util/json/object.h"
 #include "util/json/value.h"
 
-namespace Json {
+namespace Util::JSON {
 
 void Object::emplace(const std::string& name, Value value)
 {
@@ -23,4 +23,4 @@ Value& Object::operator[](const std::string& name)
 	return m_members.at(name);
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/object.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_OBJECT_H
-#define JSON_OBJECT_H
+#ifndef UTIL_JSON_OBJECT_H
+#define UTIL_JSON_OBJECT_H
 
 #include <map>
 #include <string>
@@ -13,7 +13,7 @@
 
 #include "util/json/parser.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Value;
 
@@ -50,6 +50,6 @@ private:
 	std::map<std::string, Value> m_members;
 };
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_OBJECT_H
+#endif // UTIL_JSON_OBJECT_H

src/util/json/parser.cpp

@@ -18,7 +18,7 @@
 #include "util/json/parser.h"
 #include "util/json/value.h"
 
-namespace Json {
+namespace Util::JSON {
 
 Parser::Parser(Job* job)
 	: m_job(job)
@@ -493,4 +493,4 @@ Value Parser::consumeObject()
 	return object;
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/parser.h

@@ -4,15 +4,15 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_PARSER_H
-#define JSON_PARSER_H
+#ifndef UTIL_JSON_PARSER_H
+#define UTIL_JSON_PARSER_H
 
 #include <cstddef> // size_t
 #include <vector>
 
 #include "util/json/lexer.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Job;
 class Value;
@@ -43,6 +43,6 @@ private:
 	std::vector<Token>* m_tokens { nullptr };
 };
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_PARSER_H
+#endif // UTIL_JSON_PARSER_H

src/util/json/serializer.cpp

@@ -14,7 +14,7 @@
 #include "util/json/object.h"
 #include "util/json/serializer.h"
 
-namespace Json {
+namespace Util::JSON {
 
 Serializer::Serializer(const uint32_t indent, const char indentCharacter)
 	: m_indent(indent)
@@ -151,4 +151,4 @@ void Serializer::dumpObject(const Value& value, const uint32_t indentLevel)
 	m_output += '}';
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/serializer.h

@@ -4,15 +4,15 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_SERIALIZER_H
-#define JSON_SERIALIZER_H
+#ifndef UTIL_JSON_SERIALIZER_H
+#define UTIL_JSON_SERIALIZER_H
 
 #include <cstdint> // uint32_t
 #include <string>
 
 #include "util/json/value.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Serializer {
 public:
@@ -32,6 +32,6 @@ private:
 	char m_indentCharacter { ' ' };
 };
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_SERIALIZER_H
+#endif // UTIL_JSON_SERIALIZER_H

src/util/json/tojson.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_TO_JSON_H
-#define JSON_TO_JSON_H
+#ifndef UTIL_JSON_TO_JSON_H
+#define UTIL_JSON_TO_JSON_H
 
 #include <cassert> // assert
 #include <cstddef> // nullptr_t
@@ -18,7 +18,7 @@
 #include "util/json/object.h"
 #include "util/meta/odr.h"
 
-namespace Json {
+namespace Util::JSON {
 
 namespace Detail {
 
@@ -136,9 +136,9 @@ namespace {
 constexpr const auto& toJson = Util::Detail::staticConst<Detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
 } // namespace
 
-} // namespace Json
+} // namespace Util::JSON
 
-#endif // JSON_TO_JSON_H
+#endif // UTIL_JSON_TO_JSON_H
 
 // Customization Points
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

src/util/json/value.cpp

@@ -19,7 +19,7 @@
 #include "util/json/serializer.h"
 #include "util/json/value.h"
 
-namespace Json {
+namespace Util::JSON {
 
 Value::Value(std::nullptr_t)
 	: Value(Type::Null)
@@ -337,4 +337,4 @@ void format(FormatBuilder& builder, const Value& value)
 	builder.putString(value.dump(4));
 }
 
-} // namespace Json
+} // namespace Util::JSON

src/util/json/value.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef JSON_VALUE_H
-#define JSON_VALUE_H
+#ifndef UTIL_JSON_VALUE_H
+#define UTIL_JSON_VALUE_H
 
 #include <cstddef> // nullptr_t, size_t
 #include <cstdint> // uint32_t
@@ -18,7 +18,7 @@
 #include "util/json/fromjson.h"
 #include "util/json/tojson.h"
 
-namespace Json {
+namespace Util::JSON {
 
 class Array;
 class Object;
@@ -137,7 +137,7 @@ std::ostream& operator<<(std::ostream& output, const Value& value);
 
 void format(FormatBuilder& builder, const Value& value);
 
-} // namespace Json
+} // namespace Util::JSON
 
 /**
  * User-defined string literal
@@ -149,4 +149,4 @@ inline Json::Value operator"" _json(const char* input, size_t length)
 	return Json::Value::parse(std::string(input, length));
 }
 
-#endif // JSON_VALUE_H
+#endif // UTIL_JSON_VALUE_H

test/unit/testutiljson.cpp

@@ -17,10 +17,10 @@
 #include "testsuite.h"
 #include "util/json/array.h"
 #include "util/json/job.h"
+#include "util/json/json.h"
 #include "util/json/lexer.h"
 #include "util/json/parser.h"
 #include "util/json/serializer.h"
-#include "util/json/value.h"
 
 #define DONT_PRINT_PARSER_ERRORS
 
@@ -33,20 +33,20 @@
 	stderr = Test::TestSuite::the().outputErr();
 #endif
 
-std::vector<Json::Token> lex(const std::string& input)
+std::vector<Util::JSON::Token> lex(const std::string& input)
 {
 	EXEC(
-		Json::Job job(input);
-		Json::Lexer lexer(&job);
+		Util::JSON::Job job(input);
+		Util::JSON::Lexer lexer(&job);
 		lexer.analyze(););
 	return *job.tokens();
 }
 
-Json::Value parse(const std::string& input)
+Util::Json parse(const std::string& input)
 {
 	EXEC(
-		Json::Job job(input);
-		Json::Lexer lexer(&job);
+		Util::JSON::Job job(input);
+		Util::JSON::Lexer lexer(&job);
 		lexer.analyze(););
 
 	if (!job.success()) {
@@ -54,8 +54,8 @@ Json::Value parse(const std::string& input)
 	}
 
 	EXEC(
-		Json::Parser parser(&job);
-		Json::Value json = parser.parse(););
+		Util::JSON::Parser parser(&job);
+		Util::Json json = parser.parse(););
 
 	if (!job.success()) {
 		return nullptr;
@@ -67,7 +67,7 @@ Json::Value parse(const std::string& input)
 std::string serialize(const std::string& input, uint32_t indent = 0)
 {
 	EXEC(
-		auto json = Json::Value::parse(input););
+		auto json = Util::Json::parse(input););
 	return json.dump(indent);
 }
 
@@ -75,59 +75,59 @@ std::string serialize(const std::string& input, uint32_t indent = 0)
 
 TEST_CASE(JsonLexer)
 {
-	std::vector<Json::Token> tokens;
+	std::vector<Util::JSON::Token> tokens;
 
 	// Literal
 
 	tokens = lex("true");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "true");
-	EXPECT(tokens[0].type == Json::Token::Type::Literal);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
 
 	tokens = lex("false");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "false");
-	EXPECT(tokens[0].type == Json::Token::Type::Literal);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
 
 	tokens = lex("null");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "null");
-	EXPECT(tokens[0].type == Json::Token::Type::Literal);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
 
 	// Number
 
 	tokens = lex("3.14");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "3.14");
-	EXPECT(tokens[0].type == Json::Token::Type::Number);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::Number);
 
 	tokens = lex("-3.14e+2");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "-3.14e+2");
-	EXPECT(tokens[0].type == Json::Token::Type::Number);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::Number);
 
 	tokens = lex("+3.14");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "+");
-	EXPECT(tokens[0].type == Json::Token::Type::None);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::None);
 
 	// String
 
 	tokens = lex(R"("a string")");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "a string");
-	EXPECT(tokens[0].type == Json::Token::Type::String);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::String);
 
 	tokens = lex(R"("a string""another string")");
 	EXPECT_EQ(tokens.size(), 2);
 	EXPECT_EQ(tokens[0].symbol, "a string");
 	EXPECT_EQ(tokens[1].symbol, "another string");
-	EXPECT(tokens[0].type == Json::Token::Type::String);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::String);
 
 	tokens = lex("\"a string\nwill break on the newline symbol\"");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "a string");
-	EXPECT(tokens[0].type == Json::Token::Type::String);
+	EXPECT(tokens[0].type == Util::JSON::Token::Type::String);
 
 	// Array
 
@@ -156,186 +156,186 @@ TEST_CASE(JsonLexer)
 
 TEST_CASE(JsonParser)
 {
-	Json::Value json;
+	Util::Json json;
 
 	json = parse("null");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("true");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
+	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
 
 	json = parse("false");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
+	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
 
 	json = parse("3.14");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Number);
+	EXPECT_EQ(json.type(), Util::Json::Type::Number);
 
 	json = parse(R"("a string")");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::String);
+	EXPECT_EQ(json.type(), Util::Json::Type::String);
 
 	// Array
 
 	json = parse("[");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("[ 123");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("[ 123,");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("[ 123, ]");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("[ 123 456 ]");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("[]");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
+	EXPECT_EQ(json.type(), Util::Json::Type::Array);
 
 	json = parse(R"([ "element", 3.14 ])");
 	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
+	EXPECT_EQ(json.type(), Util::Json::Type::Array);
 
 	// Object
 
 	json = parse("{");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name")");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name":)");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name":,)");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name":"value")");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name":"value",)");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name":"value", })");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ "name" "value" })");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse(R"({ 123 })");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("{}");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
+	EXPECT_EQ(json.type(), Util::Json::Type::Object);
 
 	json = parse(R"({ "name": "value", "name2": 3.14 })");
 	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
+	EXPECT_EQ(json.type(), Util::Json::Type::Object);
 
 	// Multiple root elements
 
 	json = parse("54 false");
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("3.14, 666");
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = parse("true\nfalse");
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 }
 
 TEST_CASE(JsonToJsonValue)
 {
-	Json::Value json;
+	Util::Json json;
 
 	json = {};
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = nullptr;
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
+	EXPECT_EQ(json.type(), Util::Json::Type::Null);
 
 	json = true;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
+	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
 
 	json = false;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
+	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
 
 	json = 666;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Number);
+	EXPECT_EQ(json.type(), Util::Json::Type::Number);
 
 	json = 3.14;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Number);
+	EXPECT_EQ(json.type(), Util::Json::Type::Number);
 
 	const char* characters = "my string";
 	json = characters;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::String);
+	EXPECT_EQ(json.type(), Util::Json::Type::String);
 
 	std::string string = "my string";
 	json = string;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::String);
+	EXPECT_EQ(json.type(), Util::Json::Type::String);
 
 	// Nested Array with multiple types
 	json = { "element", 3.14, true, nullptr, { "nested element", { "more nesting", { 1, 2, 3, "yes" } } } };
 	EXPECT_EQ(json.size(), 5);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
+	EXPECT_EQ(json.type(), Util::Json::Type::Array);
 
 	// Nested Object with multiple types
 	json = { { "name", "value" }, { "name2", 3.14 }, { "name3", true }, { "name4", nullptr }, { "name5", { { "nested name", "value" } } } };
 	EXPECT_EQ(json.size(), 5);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
+	EXPECT_EQ(json.type(), Util::Json::Type::Object);
 
 	// Array with singular type
 	std::vector<std::string> vector = { "element", "element2", "element3" };
 	json = vector;
 	EXPECT_EQ(json.size(), 3);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
+	EXPECT_EQ(json.type(), Util::Json::Type::Array);
 
 	// Object with singular type
 	std::map<std::string, std::string> map = { { "name", "value" }, { "name2", "value2" } };
 	json = map;
 	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
+	EXPECT_EQ(json.type(), Util::Json::Type::Object);
 
 	// Object with singular type
 	std::unordered_map<std::string, std::string> unorderedMap = { { "name", "value" }, { "name2", "value2" } };
 	json = unorderedMap;
 	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
+	EXPECT_EQ(json.type(), Util::Json::Type::Object);
 }
 
 TEST_CASE(JsonFromJsonValue)
 {
-	Json::Value json;
+	Util::Json json;
 
 	json = nullptr;
 	EXPECT_EQ(json.get<std::nullptr_t>(), nullptr);
@@ -373,7 +373,7 @@ TEST_CASE(JsonFromJsonValue)
 	EXPECT_EQ(json.at(1).get<double>(), 3.14);
 	EXPECT_EQ(json[2].get<bool>(), true);
 	EXPECT_EQ(json[3].get<std::nullptr_t>(), nullptr);
-	auto valueArray = json.get<std::vector<Json::Value>>();
+	auto valueArray = json.get<std::vector<Util::Json>>();
 	EXPECT_EQ(valueArray.size(), 4);
 	EXPECT_EQ(valueArray[0].get<std::string>(), "string");
 	EXPECT_EQ(valueArray[1].get<double>(), 3.14);
@@ -417,7 +417,7 @@ TEST_CASE(JsonFromJsonValue)
 	EXPECT_EQ(json.at("name2").get<double>(), 3.14);
 	EXPECT_EQ(json["name3"].get<bool>(), true);
 	EXPECT_EQ(json["name4"].get<std::nullptr_t>(), nullptr);
-	auto valueObject = json.get<std::map<std::string, Json::Value>>();
+	auto valueObject = json.get<std::map<std::string, Util::Json>>();
 	EXPECT_EQ(valueObject.size(), 4);
 	EXPECT_EQ(valueObject["name"].get<std::string>(), "value");
 	EXPECT_EQ(valueObject["name2"].get<double>(), 3.14);
@@ -455,25 +455,25 @@ TEST_CASE(JsonFromJsonValue)
 
 TEST_CASE(JsonImplicitConversion)
 {
-	Json::Value array;
+	Util::Json array;
 	array[0];
-	EXPECT_EQ(array.type(), Json::Value::Type::Array);
+	EXPECT_EQ(array.type(), Util::Json::Type::Array);
 
-	Json::Value arrayEmplace;
+	Util::Json arrayEmplace;
 	arrayEmplace.emplace_back("element");
 	arrayEmplace.emplace_back({ "nested element" });
-	EXPECT_EQ(arrayEmplace.type(), Json::Value::Type::Array);
-	EXPECT_EQ(arrayEmplace[1].type(), Json::Value::Type::Array);
+	EXPECT_EQ(arrayEmplace.type(), Util::Json::Type::Array);
+	EXPECT_EQ(arrayEmplace[1].type(), Util::Json::Type::Array);
 
-	Json::Value object;
+	Util::Json object;
 	object[""];
-	EXPECT_EQ(object.type(), Json::Value::Type::Object);
+	EXPECT_EQ(object.type(), Util::Json::Type::Object);
 
-	Json::Value objectEmplace;
+	Util::Json objectEmplace;
 	objectEmplace.emplace("name", "value");
 	objectEmplace.emplace("name2", { { "nested name", "value" } });
-	EXPECT_EQ(objectEmplace.type(), Json::Value::Type::Object);
-	EXPECT_EQ(objectEmplace["name2"].type(), Json::Value::Type::Object);
+	EXPECT_EQ(objectEmplace.type(), Util::Json::Type::Object);
+	EXPECT_EQ(objectEmplace["name2"].type(), Util::Json::Type::Object);
 }
 
 TEST_CASE(JsonSerializer)