Adjusted workflow.

src/json/Json.cpp

@@ -0,0 +1,487 @@
+#include "ehs/json/Json.h"
+#include "ehs/Log.h"
+
+namespace ehs
+{
+    Json::~Json()
+    {
+        delete value;
+    }
+
+    Json::Json()
+        : value(nullptr)
+    {
+    }
+
+    Json::Json(const JsonBase& value)
+        : value(new JsonBase(value))
+    {
+    }
+
+    Json::Json(const JsonObj& value)
+        : value((JsonBase*)new JsonObj(value))
+    {
+    }
+
+    Json::Json(const JsonArray& value)
+        : value((JsonBase*)new JsonArray(value))
+    {
+    }
+
+    Json::Json(const JsonBool& value)
+        : value((JsonBase*)new JsonBool(value))
+    {
+    }
+
+    Json::Json(const JsonNum& value)
+            : value((JsonBase*)new JsonNum(value))
+    {
+    }
+
+    Json::Json(const JsonStr& value)
+            : value((JsonBase*)new JsonStr(value))
+    {
+    }
+	
+	Json::Json(const char* data, const UInt_64 size, const UInt_64 extra)
+        : value(nullptr)
+	{
+        Parse({data, size}, extra);
+	}
+	
+	Json::Json(const Str_8& data, const UInt_64 extra)
+        : value(nullptr)
+	{
+        Parse(data, extra);
+	}
+
+	Json::Json(Json&& json) noexcept
+		: value(json.value)
+	{
+		json.value = nullptr;
+	}
+
+    Json::Json(const Json& json)
+        : value(nullptr)
+    {
+        if (!json.value)
+            return;
+
+        switch (json.value->GetType())
+        {
+            case JsonType::OBJ:
+                value = (JsonBase*)new JsonObj(*(JsonObj*)json.value);
+                break;
+            case JsonType::ARRAY:
+                value = (JsonBase*)new JsonArray(*(JsonArray*)json.value);
+                break;
+            case JsonType::BOOL:
+                value = (JsonBase*)new JsonBool(*(JsonBool*)json.value);
+                break;
+            case JsonType::NUM:
+                value = (JsonBase*)new JsonNum(*(JsonNum*)json.value);
+                break;
+            case JsonType::STR:
+                value = (JsonBase*)new JsonStr(*(JsonStr*)json.value);
+                break;
+            default:
+                value = new JsonBase();
+                break;
+        }
+    }
+
+	Json& Json::operator=(Json&& json) noexcept
+	{
+		if (this == &json)
+			return *this;
+
+		delete value;
+		value = json.value;
+
+		json.value = nullptr;
+
+		return *this;
+	}
+
+    Json& Json::operator=(const Json& json)
+    {
+        if (this == &json)
+            return *this;
+
+        delete value;
+        value = nullptr;
+
+        if (!json.value)
+            return *this;
+
+        switch (json.value->GetType())
+        {
+            case JsonType::OBJ:
+                value = (JsonBase*)new JsonObj(*(JsonObj*)json.value);
+                break;
+            case JsonType::ARRAY:
+                value = (JsonBase*)new JsonArray(*(JsonArray*)json.value);
+                break;
+            case JsonType::BOOL:
+                value = (JsonBase*)new JsonBool(*(JsonBool*)json.value);
+                break;
+            case JsonType::NUM:
+                value = (JsonBase*)new JsonNum(*(JsonNum*)json.value);
+                break;
+            case JsonType::STR:
+                value = (JsonBase*)new JsonStr(*(JsonStr*)json.value);
+                break;
+            default:
+                value = new JsonBase();
+                break;
+        }
+
+        return *this;
+    }
+
+    JsonBase* Json::GetValue()
+    {
+        return value;
+    }
+
+    JsonBase* Json::RetrieveValue(const Str_8& access)
+    {
+        if (!value || !access.Size())
+            return nullptr;
+
+        Vector<Str_8> levels = ParseAccess(access);
+
+        JsonBase* hierarchy = value;
+
+        for (UInt_64 i = 0; i < levels.Size(); ++i)
+        {
+            if (hierarchy->GetType() == JsonType::ARRAY)
+            {
+                if (levels[i][0] >= '0' && levels[i][0] <= '9')
+                {
+                    hierarchy = (*((JsonArray*)hierarchy))[levels[i].ToDecimal<UInt_64>()];
+                }
+                else
+                    return nullptr;
+            }
+            else if (hierarchy->GetType() == JsonType::OBJ)
+            {
+                if (levels[i][0] < '0' || levels[i][0] > '9')
+                {
+                    JsonVar* var = ((JsonObj*)hierarchy)->GetVar(levels[i]);
+                    if (!var || !var->GetValue())
+                        return nullptr;
+
+                    hierarchy = var->GetValue();
+                }
+                else
+                    return nullptr;
+            }
+            else
+                return nullptr;
+        }
+
+        return hierarchy;
+    }
+
+    Str_8 Json::ToStr(const bool compact) const
+    {
+        return value->ToStr(0, compact);
+    }
+
+    Vector<Str_8> Json::ParseAccess(const Str_8& access)
+    {
+        bool isIndex = false;
+        const Char_8* start = &access[0];
+        const Char_8* end = &access[access.Size() - 1];
+
+        Vector<Str_8> levels(0, 5);
+
+        for (const Char_8* i = &access[0]; i <= end; ++i)
+        {
+            if (*i == '[')
+            {
+                if (i - start)
+                    levels.Push(Str_8(start, i - start));
+
+                start = i + 1;
+                isIndex = true;
+            }
+            else if (*i == ']')
+            {
+                if (!isIndex)
+                {
+                    EHS_LOG_INT("Error", 0, "Index has ended, but never started.");
+                    return levels;
+                }
+
+                if (i - start)
+                    levels.Push(Str_8(start, i - start));
+                else
+                {
+                    EHS_LOG_INT("Error", 1, "Index has no value.");
+                    return levels;
+                }
+
+                start = i + 1;
+                isIndex = false;
+            }
+            else if (isIndex && (*i < '0' || *i > '9'))
+            {
+                EHS_LOG_INT("Error", 2, "Index has an invalid character, \"" + Str_8(i, 1) + "\". Index must be a whole number.");
+                return levels;
+            }
+            else if (*i == '.')
+            {
+                if (i - start)
+                    levels.Push(Str_8(start, i - start));
+
+                start = i + 1;
+            }
+            else if (!isIndex && *i != '-' && *i != '_' && (*i < 'A' || *i > 'Z') && (*i < 'a' || *i > 'z'))
+            {
+                EHS_LOG_INT("Error", 3, "Member variable has an invalid character, \"" + Str_8(i, 1) + "\".");
+                return levels;
+            }
+        }
+
+        if (end + 1 - start)
+            levels.Push(Str_8(start, end + 1 - start));
+
+        return levels;
+    }
+
+    void Json::ParseValue(JsonVar* var, const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    {
+        const Char_8* start = nullptr;
+		bool isStr = false;
+
+        for (; *begin <= end; ++(*begin))
+        {
+            if (**begin == '\"')
+            {
+                if (start)
+                {
+                    if (*begin - start)
+						((JsonStr*)var->GetValue())->value = Str_8(start, *begin - start);
+
+                    ++(*begin);
+                    return;
+                }
+                else
+				{
+					start = *begin + 1;
+					isStr = true;
+					var->SetValue(JsonStr());
+				}
+            }
+            else if (!start && **begin == '{')
+            {
+                ++(*begin);
+                JsonObj obj(extra);
+                ParseObject(&obj, begin, end, extra);
+                var->SetValue(obj);
+                return;
+            }
+            else if (!start && **begin == '[')
+            {
+                ++(*begin);
+                JsonArray arr(extra);
+                ParseArray(&arr, begin, end, extra);
+                var->SetValue(arr);
+                return;
+            }
+            else if (!start && **begin != ' ' && **begin != ',' && **begin != '\r' && **begin != '\n' && **begin != '\t')
+            {
+                start = *begin;
+            }
+            else if (start && !isStr && (**begin == '\t' || **begin == '\r' || **begin == '\n' || (!var->GetValue() && **begin == ' ') || **begin == ',' || **begin == '}' || **begin == ']'))
+            {
+                Str_8 result(start, *begin - start);
+                if (result == "true")
+                    var->SetValue(true);
+                else if (result == "false")
+                    var->SetValue(false);
+                else if (result == "null")
+                    var->SetValue(JsonBase());
+                else if (result.IsNum())
+                    var->SetValue(result.ToFloat());
+
+                return;
+            }
+        }
+    }
+
+    JsonVar Json::ParseVar(const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    {
+        JsonVar var;
+
+        const Char_8* start = nullptr;
+
+        for (; *begin <= end; ++(*begin))
+        {
+            if (**begin == '}' || **begin == ']')
+            {
+                ++(*begin);
+                return var;
+            }
+            else if (**begin == '"')
+            {
+                if (start)
+                {
+                    var = JsonVar(Str_8(start, *begin - start));
+                    start = nullptr;
+                }
+                else
+                    start = *begin + 1;
+            }
+            else if (!start && **begin == ':')
+            {
+                if (var.GetHashId())
+                {
+                    ++(*begin);
+
+                    ParseValue(&var, begin, end, extra);
+
+                    return var;
+                }
+            }
+        }
+
+        return var;
+    }
+
+    void Json::ParseObject(JsonObj* obj, const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    {
+        JsonVar var;
+        do
+        {
+            var = ParseVar(begin, end, extra);
+        }
+        while(obj->AddVar(var));
+    }
+
+    void Json::ParseArray(JsonArray* arr, const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    {
+        const Char_8* start = nullptr;
+
+        for (; *begin <= end; ++(*begin))
+        {
+            if (**begin == '}' || **begin == ']')
+            {
+                ++(*begin);
+                return;
+            }
+            else if (**begin == '\"')
+            {
+                if (start)
+                {
+                    if (*begin - start)
+                        arr->Push(start, *begin - start);
+
+					start = nullptr;
+                    ++(*begin);
+                    continue;
+                }
+                else
+                    start = *begin + 1;
+            }
+            else if (!start && **begin == '{')
+            {
+                ++(*begin);
+                JsonObj obj(extra);
+                ParseObject(&obj, begin, end, extra);
+                arr->Push(obj);
+                continue;
+            }
+            else if (!start && **begin == '[')
+            {
+                ++(*begin);
+                JsonArray array(extra);
+                ParseArray(&array, begin, end, extra);
+                arr->Push(array);
+                continue;
+            }
+            else if (!start && **begin != ' ' && **begin != ',' && **begin != '\r' && **begin != '\n' && **begin != '\t')
+            {
+                start = *begin;
+            }
+            else if (start && *start != '\"' && (**begin == '\t' || **begin == '\r' || **begin == '\n' || **begin == ' ' || **begin == ',' || **begin == '}' || **begin == ']'))
+            {
+                Str_8 result(start, *begin - start);
+                if (result == "true")
+                    arr->Push(true);
+                else if (result == "false")
+                    arr->Push(false);
+                else if (result == "null")
+                    arr->Push(JsonBase());
+                else if (result.IsNum())
+                    arr->Push(result.ToFloat());
+
+                continue;
+            }
+        }
+    }
+
+    void Json::Parse(const Str_8& data, const UInt_64 extra)
+    {
+        const Char_8* start = nullptr;
+        const Char_8* end = &data[data.Size() - 1];
+
+        for (const Char_8* i = &data[0]; i <= end; ++i)
+        {
+            if (*i == '}' || *i == ']')
+            {
+                ++i;
+                return;
+            }
+            else if (*i == '\"')
+            {
+                if (start)
+                {
+                    if (i - start)
+                        value = new JsonStr(start, i - start);
+
+                    ++i;
+                    return;
+                }
+                else
+                    start = i + 1;
+            }
+            else if (!start && *i == '{')
+            {
+                ++i;
+                JsonObj* obj = new JsonObj(extra);
+                ParseObject(obj, &i, end, extra);
+                value = obj;
+                return;
+            }
+            else if (!start && *i == '[')
+            {
+                ++i;
+                JsonArray* arr = new JsonArray(extra);
+                ParseArray(arr, &i, end, extra);
+                value = arr;
+                return;
+            }
+            else if (!start && *i != ' ' && *i != ',' && *i != '\r' && *i != '\n' && *i != '\t')
+            {
+                start = i;
+            }
+            else if (start && *start != '\"' && (*i == '\t' || *i == '\r' || *i == '\n' || *i == ' ' || *i == ',' || *i == '}' || *i == ']'))
+            {
+                Str_8 result(start, i - start);
+                if (result == "true")
+                    value = new JsonBool(true);
+                else if (result == "false")
+                    value = new JsonBool(false);
+                else if (result == "null")
+                    value = new JsonBase();
+                else if (result.IsNum())
+                    value = new JsonNum(result.ToFloat());
+
+                return;
+            }
+        }
+    }
+}

src/json/JsonArray.cpp

@@ -0,0 +1,528 @@
+#include "ehs/json/JsonArray.h"
+#include "ehs/json/JsonObj.h"
+#include "ehs/json/JsonBool.h"
+#include "ehs/json/JsonNum.h"
+#include "ehs/json/JsonStr.h"
+
+namespace ehs
+{
+	JsonArray::~JsonArray()
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			delete data[i];
+
+		delete[] data;
+	}
+
+	JsonArray::JsonArray()
+		: JsonBase(JsonType::ARRAY), size(0), extra(0), rawSize(0), data(nullptr)
+	{
+	}
+
+	JsonArray::JsonArray(const UInt_64 extra)
+		: JsonBase(JsonType::ARRAY), size(0), extra(extra), rawSize(extra), data(new JsonBase*[rawSize])
+	{
+	}
+
+	JsonArray::JsonArray(const UInt_64 size, const UInt_64 extra)
+		: JsonBase(JsonType::ARRAY), size(size), extra(extra), rawSize(size + extra), data(new JsonBase*[rawSize])
+	{
+	}
+
+	JsonArray::JsonArray(JsonArray&& ja) noexcept
+		: JsonBase(ja), size(ja.size), extra(ja.extra), rawSize(ja.rawSize), data(ja.data)
+	{
+		ja.size = 0;
+		ja.extra = 0;
+		ja.rawSize = 0;
+		ja.data = nullptr;
+	}
+
+	JsonArray::JsonArray(const JsonArray& ja)
+		: JsonBase(ja), size(ja.size), extra(ja.extra), rawSize(ja.rawSize), data(new JsonBase*[ja.rawSize])
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+		{
+			switch (ja.data[i]->GetType())
+			{
+				case JsonType::OBJ:
+					data[i] = (JsonBase*)new JsonObj(*(JsonObj*)ja.data[i]);
+					break;
+				case JsonType::ARRAY:
+					data[i] = (JsonBase*)new JsonArray(*(JsonArray*)ja.data[i]);
+					break;
+				case JsonType::BOOL:
+					data[i] = (JsonBase*)new JsonBool(*(JsonBool*)ja.data[i]);
+					break;
+				case JsonType::NUM:
+					data[i] = (JsonBase*)new JsonNum(*(JsonNum*)ja.data[i]);
+					break;
+				case JsonType::STR:
+					data[i] = (JsonBase*)new JsonStr(*(JsonStr*)ja.data[i]);
+					break;
+				default:
+					data[i] = new JsonBase();
+					break;
+			}
+		}
+	}
+
+	JsonArray& JsonArray::operator=(JsonArray&& ja) noexcept
+	{
+		if (this == &ja)
+			return *this;
+
+		JsonBase::operator=(ja);
+
+		size = ja.size;
+		extra = ja.extra;
+		rawSize = ja.rawSize;
+		delete[] data;
+		data = ja.data;
+
+		ja.size = 0;
+		ja.extra = 0;
+		ja.rawSize = 0;
+		ja.data = nullptr;
+
+		return *this;
+	}
+
+	JsonArray& JsonArray::operator=(const JsonArray& ja)
+	{
+		if (this == &ja)
+			return *this;
+
+		JsonBase::operator=(ja);
+
+		size = ja.size;
+		extra = ja.size;
+		rawSize = ja.rawSize;
+
+		delete[] data;
+		data = new JsonBase*[rawSize];
+		for (UInt_64 i = 0; i < ja.size; ++i)
+		{
+			switch (ja.data[i]->GetType())
+			{
+				case JsonType::OBJ:
+					data[i] = (JsonBase*)new JsonObj(*(JsonObj*)ja.data[i]);
+					break;
+				case JsonType::ARRAY:
+					data[i] = (JsonBase*)new JsonArray(*(JsonArray*)ja.data[i]);
+					break;
+				case JsonType::BOOL:
+					data[i] = (JsonBase*)new JsonBool(*(JsonBool*)ja.data[i]);
+					break;
+				case JsonType::NUM:
+					data[i] = (JsonBase*)new JsonNum(*(JsonNum*)ja.data[i]);
+					break;
+				case JsonType::STR:
+					data[i] = (JsonBase*)new JsonStr(*(JsonStr*)ja.data[i]);
+					break;
+				default:
+					data[i] = new JsonBase(JsonType::NULLOBJ);
+					break;
+			}
+		}
+
+		return *this;
+	}
+
+	JsonArray::operator JsonBase* const *() const
+	{
+		return data;
+	}
+
+	JsonArray::operator JsonBase**()
+	{
+		return data;
+	}
+
+	UInt_64 JsonArray::RawSize() const
+	{
+		return rawSize;
+	}
+
+	UInt_64 JsonArray::Extra() const
+	{
+		return extra;
+	}
+
+	UInt_64 JsonArray::Size() const
+	{
+		return size;
+	}
+
+	void JsonArray::Insert(const UInt_64 index, const JsonBase* const value)
+	{
+		if (size + 1 >= rawSize)
+			rawSize = size + extra;
+
+		JsonBase** result = new JsonBase*[rawSize];
+
+		for (UInt_64 i = 0; i < index; ++i)
+			result[i] = data[i];
+
+		switch (value->GetType())
+		{
+			case JsonType::OBJ:
+				result[index] = (JsonBase*)new JsonObj(*(JsonObj*)value);
+				break;
+			case JsonType::ARRAY:
+				result[index] = (JsonBase*)new JsonArray(*(JsonArray*)value);
+				break;
+			case JsonType::BOOL:
+				result[index] = (JsonBase*)new JsonBool(*(JsonBool*)value);
+				break;
+			case JsonType::NUM:
+				result[index] = (JsonBase*)new JsonNum(*(JsonNum*)value);
+				break;
+			case JsonType::STR:
+				result[index] = (JsonBase*)new JsonStr(*(JsonStr*)value);
+				break;
+			default:
+				result[index] = new JsonBase(JsonType::NULLOBJ);
+				break;
+		}
+
+		for (UInt_64 i = index; i < size; ++i)
+			result[i + 1] = data[i];
+
+		delete[] data;
+
+		data = result;
+		++size;
+	}
+
+	void JsonArray::Push(const JsonBase* const value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			switch (value->GetType())
+			{
+				case JsonType::OBJ:
+					result[size++] = (JsonBase*)new JsonObj(*(JsonObj*)value);
+					break;
+				case JsonType::ARRAY:
+					result[size++] = (JsonBase*)new JsonArray(*(JsonArray*)value);
+					break;
+				case JsonType::BOOL:
+					result[size++] = (JsonBase*)new JsonBool(*(JsonBool*)value);
+					break;
+				case JsonType::NUM:
+					result[size++] = (JsonBase*)new JsonNum(*(JsonNum*)value);
+					break;
+				case JsonType::STR:
+					result[size++] = (JsonBase*)new JsonStr(*(JsonStr*)value);
+					break;
+				default:
+					result[size++] = new JsonBase(JsonType::NULLOBJ);
+					break;
+			}
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			switch (value->GetType())
+			{
+				case JsonType::OBJ:
+					data[size++] = (JsonBase*)new JsonObj(*(JsonObj*)value);
+					break;
+				case JsonType::ARRAY:
+					data[size++] = (JsonBase*)new JsonArray(*(JsonArray*)value);
+					break;
+				case JsonType::BOOL:
+					data[size++] = (JsonBase*)new JsonBool(*(JsonBool*)value);
+					break;
+				case JsonType::NUM:
+					data[size++] = (JsonBase*)new JsonNum(*(JsonNum*)value);
+					break;
+				case JsonType::STR:
+					data[size++] = (JsonBase*)new JsonStr(*(JsonStr*)value);
+					break;
+				default:
+					data[size++] = new JsonBase(JsonType::NULLOBJ);
+					break;
+			}
+		}
+	}
+
+	void JsonArray::Push(const JsonBase& value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = new JsonBase(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = new JsonBase(value);
+		}
+	}
+
+	void JsonArray::Push(const JsonObj& value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonObj(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonObj(value);
+		}
+	}
+
+	void JsonArray::Push(const JsonArray& value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonArray(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonArray(value);
+		}
+	}
+
+	void JsonArray::Push(const JsonBool& value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonBool(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonBool(value);
+		}
+	}
+
+	void JsonArray::Push(const bool value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonBool(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonBool(value);
+		}
+	}
+
+	void JsonArray::Push(const JsonNum& value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonNum(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonNum(value);
+		}
+	}
+
+	void JsonArray::Push(const float value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonNum(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonNum(value);
+		}
+	}
+
+	void JsonArray::Push(const JsonStr& value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase*)new JsonStr(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase*)new JsonStr(value);
+		}
+	}
+
+	void JsonArray::Push(const Char_8* value, const UInt_64 size)
+	{
+		if (this->size + 1 > rawSize)
+		{
+			rawSize = this->size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < this->size; ++i)
+				result[i] = data[i];
+
+			result[this->size++] = (JsonBase*)new JsonStr(Str_8(value, size));
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[this->size++] = (JsonBase*)new JsonStr(Str_8(value, size));
+		}
+	}
+
+	void JsonArray::Push(const Str_8& value)
+	{
+		if (this->size + 1 > rawSize)
+		{
+			rawSize = this->size + extra + 1;
+			JsonBase** result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < this->size; ++i)
+				result[i] = data[i];
+
+			result[this->size++] = (JsonBase*)new JsonStr(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[this->size++] = (JsonBase*)new JsonStr(value);
+		}
+	}
+
+	void JsonArray::Pop()
+	{
+		if (rawSize - --size >= extra * 2)
+			rawSize -= extra;
+
+		JsonBase** result = new JsonBase*[rawSize];
+		for (UInt_64 i = 0; i < size; ++i)
+			result[i] = data[i];
+
+		delete[] data;
+
+		data = result;
+	}
+
+	Str_8 JsonArray::ToStr(const UInt_64 level, const bool compact) const
+	{
+		Str_8 result = "[";
+
+		if (!compact)
+			result += "\r\n";
+
+		for (UInt_64 i = 0; i < size; ++i)
+		{
+			if (!compact && (data[i]->GetType() == JsonType::OBJ || data[i]->GetType() == JsonType::ARRAY))
+			{
+				for (UInt_64 l = 0; l < level + 1; ++l)
+					result += "\t";
+			}
+
+			result += data[i]->ToStr(level + 1, compact);
+
+			if (i < size - 1)
+				result += ",";
+
+			if (!compact)
+				result += "\r\n";
+		}
+
+		if (!compact)
+		{
+			for (UInt_64 l = 0; l < level; ++l)
+				result += "\t";
+		}
+
+		result += "]";
+
+		return result;
+	}
+}

src/json/JsonBase.cpp

@@ -0,0 +1,24 @@
+#include "ehs/json/JsonBase.h"
+
+namespace ehs
+{
+	JsonBase::JsonBase()
+			: type(JsonType::NULLOBJ)
+	{
+	}
+
+	JsonBase::JsonBase(const JsonType type)
+			: type(type)
+	{
+	}
+
+	JsonType JsonBase::GetType() const
+	{
+		return type;
+	}
+
+	Str_8 JsonBase::ToStr(const UInt_64 level, const bool compact) const
+	{
+		return {};
+	}
+}

src/json/JsonBool.cpp

@@ -0,0 +1,39 @@
+#include "ehs/json/JsonBool.h"
+
+namespace ehs
+{
+	JsonBool::JsonBool()
+			: JsonBase(JsonType::BOOL), value(false)
+	{
+	}
+
+	JsonBool::JsonBool(const bool value)
+			: JsonBase(JsonType::BOOL), value(value)
+	{
+	}
+
+	JsonBool::operator bool() const
+	{
+		return value;
+	}
+
+	JsonBool::operator bool&()
+	{
+		return value;
+	}
+
+	Str_8 JsonBool::ToStr(const UInt_64 level, const bool compact) const
+	{
+		Str_8 result;
+
+		if (!compact)
+		{
+			for (UInt_64 l = 0; l < level; ++l)
+				result += "\t";
+		}
+
+		result += value ? "true" : "false";
+
+		return result;
+	}
+}

src/json/JsonNum.cpp

@@ -0,0 +1,93 @@
+#include "ehs/json/JsonNum.h"
+
+namespace ehs
+{
+	JsonNum::JsonNum()
+		: JsonBase(JsonType::NUM), value(0.0f)
+	{
+	}
+
+	JsonNum::JsonNum(const SInt_64 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const UInt_64 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const SInt_32 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const UInt_32 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const SInt_16 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const UInt_16 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const SInt_8 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const UInt_8 value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const double value)
+		: JsonBase(JsonType::NUM), value((float)value)
+	{
+
+	}
+
+	JsonNum::JsonNum(const float value)
+		: JsonBase(JsonType::NUM), value(value)
+	{
+	}
+
+	JsonNum::operator float() const
+	{
+		return value;
+	}
+
+	JsonNum::operator float&()
+	{
+		return value;
+	}
+
+	Str_8 JsonNum::ToStr(const UInt_64 level, const bool compact) const
+	{
+		Str_8 result;
+
+		if (!compact)
+		{
+			for (UInt_64 l = 0; l < level; ++l)
+				result += "\t";
+		}
+
+		result += Str_8::FromNum(value);
+
+		return result;
+	}
+}

src/json/JsonObj.cpp

@@ -0,0 +1,201 @@
+#include "ehs/json/JsonObj.h"
+#include "ehs/json/JsonVar.h"
+
+namespace ehs
+{
+	JsonObj::~JsonObj()
+	{
+		delete[] vars;
+	}
+
+	JsonObj::JsonObj()
+		: JsonBase(JsonType::OBJ), size(0), extra(0), rawSize(0), vars(nullptr)
+	{
+	}
+
+	JsonObj::JsonObj(const UInt_64 size, const UInt_64 extra)
+		: JsonBase(JsonType::OBJ), size(size), extra(extra), rawSize(size + extra), vars(new JsonVar[size + extra])
+	{
+	}
+
+	JsonObj::JsonObj(const UInt_64 extra)
+		: JsonBase(JsonType::OBJ), size(0), extra(extra), rawSize(extra), vars(new JsonVar[extra])
+	{
+	}
+
+	JsonObj::JsonObj(JsonObj&& value) noexcept
+		: JsonBase(value), size(value.size), extra(value.extra), rawSize(value.rawSize), vars(value.vars)
+	{
+		value.size = 0;
+		value.extra = 0;
+		value.rawSize = 0;
+		value.vars = nullptr;
+	}
+
+	JsonObj::JsonObj(const JsonObj& value)
+		: JsonBase(value), size(value.size), extra(value.extra), rawSize(value.rawSize), vars(new JsonVar[value.rawSize])
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			vars[i] = value.vars[i];
+	}
+
+	JsonObj& JsonObj::operator=(JsonObj&& value) noexcept
+	{
+		if (this == &value)
+			return *this;
+
+		JsonBase::operator=(value);
+
+		size = value.size;
+		extra = value.extra;
+		rawSize = value.rawSize;
+		delete[] vars;
+		vars = value.vars;
+
+		value.size = 0;
+		value.extra = 0;
+		value.rawSize = 0;
+		value.vars = nullptr;
+
+		return *this;
+	}
+
+	JsonObj& JsonObj::operator=(const JsonObj& value)
+	{
+		if (this == &value)
+			return *this;
+
+		JsonBase::operator=(value);
+
+		size = value.size;
+		extra = value.extra;
+		rawSize = value.rawSize;
+
+		delete[] vars;
+		vars = new JsonVar[value.rawSize];
+		for (UInt_64 i = 0; i < value.rawSize; ++i)
+			vars[i] = value.vars[i];
+
+		return *this;
+	}
+
+	JsonObj::operator const JsonVar*() const
+	{
+		return vars;
+	}
+
+	JsonObj::operator JsonVar*()
+	{
+		return vars;
+	}
+
+	UInt_64 JsonObj::Size() const
+	{
+		return size;
+	}
+
+	UInt_64 JsonObj::Extra() const
+	{
+		return extra;
+	}
+
+	UInt_64 JsonObj::RawSize() const
+	{
+		return rawSize;
+	}
+
+	bool JsonObj::HasVar(const UInt_64 hashId) const
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			if (vars[i].GetHashId() == hashId)
+				return true;
+
+		return false;
+	}
+
+	bool JsonObj::HasVar(const Str_8& identifier) const
+	{
+		return HasVar(identifier.Hash_64());
+	}
+
+	bool JsonObj::AddVar(const JsonVar& var)
+	{
+		if (!var.GetHashId() || HasVar(var.GetHashId()))
+			return false;
+
+		if (size + 1 > rawSize)
+		{
+			rawSize += extra ? extra : 1;
+			JsonVar* result = new JsonVar[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = vars[i];
+
+			delete[] vars;
+			vars = result;
+		}
+
+		vars[size++] = var;
+
+		return true;
+	}
+
+	const JsonVar* JsonObj::GetVar(const UInt_64 hashId) const
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			if (vars[i].GetHashId() == hashId)
+				return &vars[i];
+
+		return nullptr;
+	}
+
+	const JsonVar* JsonObj::GetVar(const Str_8& identifier) const
+	{
+		return GetVar(identifier.Hash_64());
+	}
+
+	JsonVar* JsonObj::GetVar(const UInt_64 hashId)
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			if (vars[i].GetHashId() == hashId)
+				return &vars[i];
+
+		return nullptr;
+	}
+
+	JsonVar* JsonObj::GetVar(const Str_8& identifier)
+	{
+		return GetVar(identifier.Hash_64());
+	}
+
+	Str_8 JsonObj::ToStr(const UInt_64 level, const bool compact) const
+	{
+		Str_8 result;
+
+		result += "{";
+
+		if (!compact)
+			result += "\r\n";
+
+		for (UInt_64 i = 0; i < size; ++i)
+		{
+			result += vars[i].ToStr(level + 1, compact);
+
+			if (i < size - 1)
+				result += ",";
+
+			if (!compact)
+				result += "\r\n";
+		}
+
+		if (!compact)
+		{
+			for (UInt_64 l = 0; l < level; ++l)
+				result += "\t";
+		}
+
+		result += "}";
+
+		return result;
+	}
+}

src/json/JsonStr.cpp

@@ -0,0 +1,62 @@
+#include "ehs/json/JsonStr.h"
+
+namespace ehs
+{
+	JsonStr::JsonStr()
+			: JsonBase(JsonType::STR)
+	{
+	}
+
+	JsonStr::JsonStr(Str_8 value)
+			: JsonBase(JsonType::STR), value(std::move(value))
+	{
+
+	}
+
+	JsonStr::JsonStr(const Char_8* value, const UInt_64 size)
+			: JsonBase(JsonType::STR), value(value, size)
+	{
+	}
+
+	JsonStr::JsonStr(JsonStr&& js) noexcept
+		: JsonBase(js), value(std::move(js.value))
+	{
+	}
+
+	JsonStr& JsonStr::operator=(JsonStr&& js) noexcept
+	{
+		if (this == &js)
+			return *this;
+
+		JsonBase::operator=(js);
+
+		value = std::move(js.value);
+
+		return *this;
+	}
+
+	JsonStr::operator Str_8() const
+	{
+		return value;
+	}
+
+	JsonStr::operator Str_8&()
+	{
+		return value;
+	}
+
+	Str_8 JsonStr::ToStr(const UInt_64 level, const bool compact) const
+	{
+		Str_8 result;
+
+		if (!compact)
+		{
+			for (UInt_64 l = 0; l < level; ++l)
+				result += "\t";
+		}
+
+		result += "\"" + value + "\"";
+
+		return result;
+	}
+}

src/json/JsonVar.cpp

@@ -0,0 +1,369 @@
+#include "ehs/json/JsonVar.h"
+#include "ehs/json/JsonBase.h"
+#include "ehs/json/JsonObj.h"
+#include "ehs/json/JsonArray.h"
+#include "ehs/json/JsonBool.h"
+#include "ehs/json/JsonNum.h"
+#include "ehs/json/JsonStr.h"
+
+namespace ehs
+{
+	JsonVar::~JsonVar()
+	{
+		delete value;
+	}
+
+	JsonVar::JsonVar()
+		: hashId(0), value(nullptr)
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id)
+		: hashId(id.Hash_64()), id(std::move(id)), value(nullptr)
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonBase* const value)
+		: hashId(id.Hash_64()), id(std::move(id))
+	{
+		switch (value->GetType())
+		{
+			case JsonType::OBJ:
+				this->value = (JsonBase*)new JsonObj(*(JsonObj*)value);
+				break;
+			case JsonType::ARRAY:
+				this->value = (JsonBase*)new JsonArray(*(JsonArray*)value);
+				break;
+			case JsonType::BOOL:
+				this->value = (JsonBase*)new JsonBool(*(JsonBool*)value);
+				break;
+			case JsonType::NUM:
+				this->value = (JsonBase*)new JsonNum(*(JsonNum*)value);
+				break;
+			case JsonType::STR:
+				this->value = (JsonBase*)new JsonStr(*(JsonStr*)value);
+				break;
+			default:
+				this->value = new JsonBase(JsonType::NULLOBJ);
+				break;
+		}
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonBase& value)
+		: hashId(id.Hash_64()), id(std::move(id)), value(new JsonBase(value))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonObj& value)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonObj(value))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonArray& value)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonArray(value))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonBool& value)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonBool(value))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const bool boolean)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonBool(boolean))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonNum& value)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(value))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const SInt_64 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const UInt_64 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const SInt_32 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const UInt_32 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const SInt_16 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const UInt_16 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const SInt_8 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const UInt_8 num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const double num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const float num)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(num))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const JsonStr& value)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonStr(value))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, const Char_8* str, const UInt_64 size)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonStr(str, size))
+	{
+	}
+
+	JsonVar::JsonVar(Str_8 id, Str_8 str)
+		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonStr(std::move(str)))
+	{
+	}
+
+	JsonVar::JsonVar(JsonVar&& var) noexcept
+		: hashId(var.hashId), id(std::move(var.id)), value(var.value)
+	{
+		var.hashId = 0;
+		var.value = nullptr;
+	}
+
+	JsonVar::JsonVar(const JsonVar& var)
+		: hashId(var.hashId), id(var.id), value(nullptr)
+	{
+		if (!var.value)
+			return;
+
+		switch (var.value->GetType())
+		{
+			case JsonType::OBJ:
+				value = (JsonBase*)new JsonObj(*(JsonObj*)var.value);
+				break;
+			case JsonType::ARRAY:
+				value = (JsonBase*)new JsonArray(*(JsonArray*)var.value);
+				break;
+			case JsonType::BOOL:
+				value = (JsonBase*)new JsonBool(*(JsonBool*)var.value);
+				break;
+			case JsonType::NUM:
+				value = (JsonBase*)new JsonNum(*(JsonNum*)var.value);
+				break;
+			case JsonType::STR:
+				value = (JsonBase*)new JsonStr(*(JsonStr*)var.value);
+				break;
+			default:
+				value = new JsonBase();
+				break;
+		}
+	}
+
+	JsonVar& JsonVar::operator=(JsonVar&& var) noexcept
+	{
+		if (this == &var)
+			return *this;
+
+		hashId = var.hashId;
+		id = std::move(var.id);
+		delete value;
+		value = var.value;
+
+		var.hashId = 0;
+		var.value = nullptr;
+
+		return *this;
+	}
+
+	JsonVar& JsonVar::operator=(const JsonVar& var)
+	{
+		if (this == &var)
+			return *this;
+
+		hashId = var.hashId;
+		id = var.id;
+		delete value;
+		value = nullptr;
+
+		if (!var.value)
+			return *this;
+
+		switch (var.value->GetType())
+		{
+			case JsonType::OBJ:
+				value = (JsonBase*)new JsonObj(*(JsonObj*)var.value);
+				break;
+			case JsonType::ARRAY:
+				value = (JsonBase*)new JsonArray(*(JsonArray*)var.value);
+				break;
+			case JsonType::BOOL:
+				value = (JsonBase*)new JsonBool(*(JsonBool*)var.value);
+				break;
+			case JsonType::NUM:
+				value = (JsonBase*)new JsonNum(*(JsonNum*)var.value);
+				break;
+			case JsonType::STR:
+				value = (JsonBase*)new JsonStr(*(JsonStr*)var.value);
+				break;
+			default:
+				value = new JsonBase();
+				break;
+		}
+
+		return *this;
+	}
+
+	UInt_64 JsonVar::GetHashId() const
+	{
+		return hashId;
+	}
+
+	Str_8 JsonVar::GetId() const
+	{
+		return id;
+	}
+
+	void JsonVar::SetValue(const JsonBase* const newValue)
+	{
+		if (!newValue)
+			return;
+
+		delete value;
+
+		switch (newValue->GetType())
+		{
+			case JsonType::OBJ:
+				value = (JsonBase*)new JsonObj(*(JsonObj*)newValue);
+				break;
+			case JsonType::ARRAY:
+				value = (JsonBase*)new JsonArray(*(JsonArray*)newValue);
+				break;
+			case JsonType::BOOL:
+				value = (JsonBase*)new JsonBool(*(JsonBool*)newValue);
+				break;
+			case JsonType::NUM:
+				value = (JsonBase*)new JsonNum(*(JsonNum*)newValue);
+				break;
+			case JsonType::STR:
+				value = (JsonBase*)new JsonStr(*(JsonStr*)newValue);
+				break;
+			default:
+				value = new JsonBase();
+				break;
+		}
+	}
+
+	void JsonVar::SetValue(const JsonBase& newValue)
+	{
+		delete value;
+		value = new JsonBase(newValue);
+	}
+
+	void JsonVar::SetValue(const JsonObj& newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonObj(newValue);
+	}
+
+	void JsonVar::SetValue(const JsonArray& newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonArray(newValue);
+	}
+
+	void JsonVar::SetValue(const JsonBool& newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonBool(newValue);
+	}
+
+	void JsonVar::SetValue(const bool newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonBool(newValue);
+	}
+
+	void JsonVar::SetValue(const JsonNum& newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonNum(newValue);
+	}
+
+	void JsonVar::SetValue(const float newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonNum(newValue);
+	}
+
+	void JsonVar::SetValue(const JsonStr& newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonStr(newValue);
+	}
+
+	void JsonVar::SetValue(const Char_8* newValue, const UInt_64 size)
+	{
+		delete value;
+		value = (JsonBase*)new JsonStr(newValue, size);
+	}
+
+	void JsonVar::SetValue(const Str_8& newValue)
+	{
+		delete value;
+		value = (JsonBase*)new JsonStr(newValue);
+	}
+
+	const JsonBase* JsonVar::GetValue() const
+	{
+		return value;
+	}
+
+	JsonBase* JsonVar::GetValue()
+	{
+		return value;
+	}
+
+	Str_8 JsonVar::ToStr(const UInt_64 level, const bool compact) const
+	{
+		Str_8 result;
+
+		if (!compact)
+		{
+			for (UInt_64 l = 0; l < level; ++l)
+				result += "\t";
+		}
+
+		result += "\"" + id + "\":";
+
+		if (!compact)
+			result += " ";
+
+		if (value->GetType() == JsonType::OBJ || value->GetType() == JsonType::ARRAY)
+			result += value->ToStr(level, compact);
+		else
+			result += value->ToStr(0, compact);
+
+		return result;
+	}
+}