SilverMoonStudio/EHS
3
0
Fork 0
Code Issues 8 Pull Requests Actions Projects 1 Releases 6 Wiki Activity

Reorganized project again.

Browse Source
This commit is contained in:
karutoh
2023-12-17 15:56:13 -08:00
parent 54b9e82789
commit 3acb78f247
250 changed files with 1586 additions and 1586 deletions
Download Patch File Download Diff File Expand all files Collapse all files

487
src/json/Json.cpp Normal file
View File

@@ -0,0 +1,487 @@
#include "json/Json.h"
#include "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;
}
}
}
}

528
src/json/JsonArray.cpp Normal file
View File

@@ -0,0 +1,528 @@
#include "json/JsonArray.h"
#include "json/JsonObj.h"
#include "json/JsonBool.h"
#include "json/JsonNum.h"
#include "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;
}
}

24
src/json/JsonBase.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include "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 {};
}
}

39
src/json/JsonBool.cpp Normal file
View File

@@ -0,0 +1,39 @@
#include "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;
}
}

93
src/json/JsonNum.cpp Normal file
View File

@@ -0,0 +1,93 @@
#include "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;
}
}

201
src/json/JsonObj.cpp Normal file
View File

@@ -0,0 +1,201 @@
#include "json/JsonObj.h"
#include "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;
}
}

62
src/json/JsonStr.cpp Normal file
View File

@@ -0,0 +1,62 @@
#include "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;
}
}

369
src/json/JsonVar.cpp Normal file
View File

@@ -0,0 +1,369 @@
#include "json/JsonVar.h"
#include "json/JsonBase.h"
#include "json/JsonObj.h"
#include "json/JsonArray.h"
#include "json/JsonBool.h"
#include "json/JsonNum.h"
#include "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;
}
}