drinkingtea/nostalgia
2
0
Fork 0
Code Issues 4 Pull Requests Actions Releases 13 Activity

[ox/model] Harmonize make the interface for walking over models

Browse Source
This commit is contained in:
Gary Talent
2020-04-09 22:49:56 -05:00
parent a4000f6497
commit 5d95b188d8
17 changed files with 376 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
deps/ox/src/ox/oc/read.cpp vendored
View File

@@ -1,108 +1,220 @@
/*
* Copyright 2015 - 2018 gtalent2@gmail.com
* Copyright 2015 - 2020 gtalent2@gmail.com
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include <ox/std/bit.hpp>
#include "read.hpp"
namespace ox {
template<typename Key>
OrganicClawReader<Key>::OrganicClawReader(Json::Value json) {
OrganicClawReader<Key>::OrganicClawReader(const uint8_t *buff, std::size_t buffSize) {
auto json = bit_cast<const char*>(buff);
auto jsonLen = ox_strnlen(json, buffSize);
Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader());
if (!parser->parse(json, json + jsonLen, &m_json, nullptr)) {
throw OxError(1, "Could not parse JSON");
}
}
template<typename Key>
OrganicClawReader<Key>::OrganicClawReader(const char *json, std::size_t jsonLen) {
Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader());
if (!parser->parse(json, json + jsonLen, &m_json, nullptr)) {
throw OxError(1, "Could not parse JSON");
}
}
template<typename Key>
OrganicClawReader<Key>::OrganicClawReader(const Json::Value &json) {
m_json = json;
}
template<typename Key>
OrganicClawReader<Key>::~OrganicClawReader() {
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, int8_t *val) {
*val = static_cast<int8_t>(m_json[key].asInt());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isInt()) {
*val = static_cast<int8_t>(jv.asInt());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, int16_t *val) {
*val = static_cast<int16_t>(m_json[key].asInt());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isInt()) {
*val = static_cast<int16_t>(jv.asInt());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, int32_t *val) {
*val = static_cast<int32_t>(m_json[key].asInt());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isInt()) {
*val = static_cast<int32_t>(jv.asInt());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, int64_t *val) {
*val = static_cast<int64_t>(m_json[key].asInt64());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isInt() || jv.isInt64()) {
*val = static_cast<int64_t>(jv.asInt64());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, uint8_t *val) {
*val = static_cast<uint8_t>(m_json[key].asUInt());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isUInt()) {
*val = static_cast<uint8_t>(jv.asUInt());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, uint16_t *val) {
*val = static_cast<uint16_t>(m_json[key].asUInt());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isUInt()) {
*val = static_cast<uint16_t>(jv.asUInt());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, uint32_t *val) {
*val = static_cast<uint32_t>(m_json[key].asUInt());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isUInt()) {
*val = static_cast<uint32_t>(jv.asUInt());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, uint64_t *val) {
*val = static_cast<uint64_t>(m_json[key].asUInt64());
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isUInt() || jv.isUInt64()) {
*val = static_cast<uint64_t>(jv.asUInt64());
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, bool *val) {
*val = m_json[key].asBool();
return OxError(0);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isBool()) {
*val = jv.asBool();
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
Error OrganicClawReader<Key>::field(Key key, SerStr val) {
const char *begin = nullptr, *end = nullptr;
m_json[key].getString(&begin, &end);
auto strSize = end - begin;
if (strSize >= val.cap()) {
return OxError(1);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
ox_memcpy(val.data(), begin, static_cast<std::size_t>(strSize));
val.data()[strSize] = 0;
return OxError(0);
if (jv.isString()) {
jv.getString(&begin, &end);
auto strSize = end - begin;
if (strSize >= val.cap()) {
return OxError(1, "String size exceeds capacity of destination");
}
ox_memcpy(val.data(), begin, static_cast<std::size_t>(strSize));
val.data()[strSize] = 0;
return OxError(0);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
[[nodiscard]] std::size_t OrganicClawReader<Key>::arrayLength(Key key, bool) {
return m_json[key].size();
[[nodiscard]] ValErr<std::size_t> OrganicClawReader<Key>::arrayLength(Key key, bool) {
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return 0;
}
if (jv.isArray()) {
return jv.size();
}
return OxError(1, "Type mismatch");
}
template<typename Key>
[[nodiscard]] std::size_t OrganicClawReader<Key>::stringLength(Key key) {
const char *begin = nullptr, *end = nullptr;
m_json[key].getString(&begin, &end);
return static_cast<std::size_t>(end - begin);
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return 0;
}
if (jv.isString()) {
jv.getString(&begin, &end);
return static_cast<std::size_t>(end - begin);
}
return OxError(1, "Type mismatch");
}
template<typename Key>
void OrganicClawReader<Key>::setTypeInfo(const char*, int fields) {
m_fields = fields;
m_buffIt = static_cast<std::size_t>((fields / 8 + 1) - (fields % 8 == 0));
void OrganicClawReader<Key>::setTypeInfo(const char*, int) {
}
template<typename Key>
@@ -110,6 +222,20 @@ OrganicClawReader<Key> OrganicClawReader<Key>::child(Key key) {
return OrganicClawReader<Key>(m_json[key]);
}
template<typename Key>
bool OrganicClawReader<Key>::fieldPresent(Key key) {
return !m_json[key].empty();
}
template<typename Key>
Json::Value &OrganicClawReader<Key>::value(Key key) {
if (m_json.isArray()) {
return m_json[m_fieldIt];
} else {
return m_json[key];
}
}
template class OrganicClawReader<const char*>;
template class OrganicClawReader<Json::ArrayIndex>;

72
deps/ox/src/ox/oc/read.hpp vendored
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015 - 2018 gtalent2@gmail.com
* Copyright 2015 - 2020 gtalent2@gmail.com
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
@@ -23,16 +23,16 @@ class OrganicClawReader {
private:
Json::Value m_json;
int m_fields = 0;
int m_field = 0;
std::size_t m_buffIt = 0;
std::size_t m_buffLen = 0;
uint8_t *m_buff = nullptr;
Json::ArrayIndex m_fieldIt = 0;
public:
OrganicClawReader(Json::Value json = {});
OrganicClawReader() = default;
~OrganicClawReader();
OrganicClawReader(const uint8_t *buff, std::size_t buffSize);
OrganicClawReader(const char *json, std::size_t buffSize);
OrganicClawReader(const Json::Value &json);
[[nodiscard]] Error field(Key key, int8_t *val);
[[nodiscard]] Error field(Key key, int16_t *val);
@@ -65,7 +65,7 @@ class OrganicClawReader {
* Reads an array length from the current location in the buffer.
* @param pass indicates that the parsing should iterate past the array length
*/
[[nodiscard]] std::size_t arrayLength(Key key, bool pass = true);
[[nodiscard]] ValErr<std::size_t> arrayLength(Key key, bool pass = true);
/**
* Reads an string length from the current location in the buffer.
@@ -79,18 +79,34 @@ class OrganicClawReader {
*/
[[nodiscard]] OrganicClawReader child(Key key);
static constexpr OpType opType() {
// compatibility stub
constexpr void nextField() noexcept {}
bool fieldPresent(Key key);
static constexpr auto opType() {
return OpType::Read;
}
private:
Json::Value &value(Key key);
};
template<typename Key>
template<typename T>
Error OrganicClawReader<Key>::field(Key key, T *val) {
if (val) {
auto reader = child(key);
oxReturnError(model(&reader, val));
const auto &jv = value(key);
++m_fieldIt;
if (jv.empty()) {
return OxError(0);
}
if (jv.isObject()) {
auto reader = child(key);
return model(&reader, val);
}
}
return OxError(0);
}
@@ -110,9 +126,9 @@ Error OrganicClawReader<Key>::field(Key key, T *val, std::size_t valLen) {
if (srcSize > valLen) {
return OxError(1);
}
OrganicClawReader<Json::ArrayIndex> r(srcVal);
OrganicClawReader<const char*> r(srcVal);
for (decltype(srcSize) i = 0; i < srcSize; ++i) {
oxReturnError(r.field(i, &val[i]));
oxReturnError(r.field("", &val[i]));
}
return OxError(0);
}
@@ -124,16 +140,28 @@ Error OrganicClawReader<Key>::field(Key key, ox::Vector<T> *val) {
}
template<typename T>
ValErr<T> readOC(const char *json) {
Json::Value doc;
Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader());
if (!parser->parse(json, json + ox_strlen(json), &doc, nullptr)) {
return OxError(1, "Could not parse JSON");
Error readOC(const char *json, std::size_t jsonSize, T *val) noexcept {
// OrganicClawReader constructor can throw, but readOC should return its errors.
try {
Json::Value doc;
Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader());
if (!parser->parse(json, json + jsonSize, &doc, nullptr)) {
return OxError(1, "Could not parse JSON");
}
OrganicClawReader<const char*> reader(json, jsonSize);
return model(&reader, val);
} catch (Error err) {
return err;
} catch (...) {
return OxError(1, "Unkown Error");
}
OrganicClawReader<const char*> reader(doc);
}
template<typename T>
ValErr<T> readOC(const char *json) {
T val;
oxReturnError(model(&reader, &val));
oxReturnError(readOC(json, ox_strlen(json), &val));
return {std::move(val), OxError(0)};
}

1
deps/ox/src/ox/oc/test/CMakeLists.txt vendored
View File

@@ -10,3 +10,4 @@ target_link_libraries(
add_test("Test\\ OcTest\\ Writer" OcTest OrganicClawWriter)
add_test("Test\\ OcTest\\ Reader" OcTest OrganicClawReader)
add_test("Test\\ OcTest\\ OrganicClawDef" OcTest OrganicClawDef)

222
deps/ox/src/ox/oc/test/tests.cpp vendored
View File

@@ -8,14 +8,12 @@
#undef NDEBUG
#include <assert.h>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <ox/oc/oc.hpp>
#include <ox/model/model.hpp>
#include <ox/oc/oc.hpp>
#include <ox/std/std.hpp>
struct TestStructNest {
@@ -128,119 +126,115 @@ std::map<std::string, ox::Error(*)()> tests = {
return OxError(0);
}
},
//{
// "OrganicClawDef",
// [] {
// auto err = OxError(0);
// //constexpr size_t descBuffLen = 1024;
// //uint8_t descBuff[descBuffLen];
// constexpr size_t dataBuffLen = 1024;
// uint8_t dataBuff[dataBuffLen];
// TestStruct testIn, testOut;
{
"OrganicClawDef",
[] {
TestStruct testIn, testOut;
// testIn.Bool = true;
// testIn.Int = 42;
// testIn.String = "Test String 1";
// testIn.List[0] = 1;
// testIn.List[1] = 2;
// testIn.List[2] = 3;
// testIn.List[3] = 4;
// testIn.Struct.Bool = false;
// testIn.Struct.Int = 300;
// testIn.Struct.String = "Test String 2";
testIn.Bool = true;
testIn.Int = 42;
testIn.String = "Test String 1";
testIn.List[0] = 1;
testIn.List[1] = 2;
testIn.List[2] = 3;
testIn.List[3] = 4;
testIn.Struct.Bool = false;
testIn.Struct.Int = 300;
testIn.Struct.String = "Test String 2";
// oxAssert(ox::writeOC(&testIn), "Data generation failed");
// auto type = ox::buildMCDef(&testIn);
// oxAssert(type.error, "Descriptor write failed");
// ox::walkMC<ox::OrganicClawReader<const char*>>(type.value, dataBuff, dataBuffLen,
// [](const ox::Vector<ox::FieldName>&, const ox::Vector<ox::TypeName>&, const ox::DescriptorField &f, ox::OrganicClawReader<const char*> *rdr) -> ox::Error {
// //std::cout << f.fieldName.c_str() << '\n';
// auto fieldName = f.fieldName.c_str();
// switch (f.type->primitiveType) {
// case ox::PrimitiveType::UnsignedInteger:
// std::cout << fieldName << ":\tuint" << f.type->length * 8 << "_t:\t";
// switch (f.type->length) {
// case 1: {
// uint8_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// case 2: {
// uint16_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// case 4: {
// uint32_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// case 8: {
// uint64_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// }
// std::cout << '\n';
// break;
// case ox::PrimitiveType::SignedInteger:
// std::cout << fieldName << ":\tint" << f.type->length * 8 << "_t:\t";
// switch (f.type->length) {
// case 1: {
// int8_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// case 2: {
// int16_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// case 4: {
// int32_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// case 8: {
// int64_t i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << i;
// break;
// }
// }
// std::cout << '\n';
// break;
// case ox::PrimitiveType::Bool: {
// bool i = {};
// oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
// std::cout << fieldName << ":\t" << "bool:\t" << (i ? "true" : "false") << '\n';
// break;
// }
// case ox::PrimitiveType::String: {
// ox::Vector<char> v(rdr->stringLength());
// //std::cout << rdr->stringLength() << '\n';
// oxAssert(rdr->field(fieldName, ox::SerStr(v.data(), v.size())), "Walking model failed.");
// std::cout << fieldName << ":\t" << "string: " << v.data() << '\n';
// break;
// }
// case ox::PrimitiveType::Struct:
// break;
// }
// return OxError(0);
// }
// );
// delete type.value;
auto [oc, ocErr] = ox::writeOC(&testIn);
oxAssert(ocErr, "Data generation failed");
auto type = ox::buildTypeDef(&testIn);
oxAssert(type.error, "Descriptor write failed");
ox::walkModel<ox::OrganicClawReader<const char*>>(type.value, ox::bit_cast<uint8_t*>(oc.c_str()), oc.len() + 1,
[](const ox::Vector<ox::FieldName>&, const ox::Vector<ox::TypeName>&, const ox::DescriptorField &f, ox::OrganicClawReader<const char*> *rdr) -> ox::Error {
//std::cout << f.fieldName.c_str() << '\n';
auto fieldName = f.fieldName.c_str();
switch (f.type->primitiveType) {
case ox::PrimitiveType::UnsignedInteger:
std::cout << fieldName << ":\tuint" << f.type->length * 8 << "_t:\t";
switch (f.type->length) {
case 1: {
uint8_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 2: {
uint16_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 4: {
uint32_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 8: {
uint64_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
}
std::cout << '\n';
break;
case ox::PrimitiveType::SignedInteger:
std::cout << fieldName << ":\tint" << f.type->length * 8 << "_t:\t";
switch (f.type->length) {
case 1: {
int8_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 2: {
int16_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 4: {
int32_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 8: {
int64_t i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
}
std::cout << '\n';
break;
case ox::PrimitiveType::Bool: {
bool i = {};
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << fieldName << ":\t" << "bool:\t" << (i ? "true" : "false") << '\n';
break;
}
case ox::PrimitiveType::String: {
ox::Vector<char> v(rdr->stringLength(fieldName) + 1);
//std::cout << rdr->stringLength() << '\n';
oxAssert(rdr->field(fieldName, ox::SerStr(v.data(), v.size())), "Walking model failed.");
std::cout << fieldName << ":\t" << "string: " << v.data() << '\n';
break;
}
case ox::PrimitiveType::Struct:
break;
}
return OxError(0);
}
);
delete type.value;
// return err;
// }
//},
return OxError(0);
}
},
}
};

7
deps/ox/src/ox/oc/write.cpp vendored
View File

@@ -15,10 +15,6 @@ OrganicClawWriter<Key>::OrganicClawWriter(Json::Value json) {
m_json = json;
}
template<typename Key>
OrganicClawWriter<Key>::~OrganicClawWriter() {
}
template<typename Key>
Error OrganicClawWriter<Key>::field(Key key, int8_t *val) {
if (*val) {
@@ -109,8 +105,7 @@ Error OrganicClawWriter<Key>::field(Key key, SerStr val) {
}
template<typename Key>
void OrganicClawWriter<Key>::setTypeInfo(const char*, int fields) {
m_fields = fields;
void OrganicClawWriter<Key>::setTypeInfo(const char*, int) {
}
template class OrganicClawWriter<const char*>;

7
deps/ox/src/ox/oc/write.hpp vendored
View File

@@ -26,17 +26,12 @@ class OrganicClawWriter {
protected:
Json::Value m_json;
int m_fields = 0;
int m_field = 0;
uint8_t *m_buff = nullptr;
public:
OrganicClawWriter() = default;
OrganicClawWriter(Json::Value json);
~OrganicClawWriter();
Error field(Key, int8_t *val);
Error field(Key, int16_t *val);
Error field(Key, int32_t *val);
@@ -67,7 +62,7 @@ class OrganicClawWriter {
void setTypeInfo(const char *name, int fields);
static constexpr OpType opType() {
static constexpr auto opType() {
return OpType::Write;
}