drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 6 Pull Requests Actions Releases 9 Activity

[ox/model] Rename ioOp and op to model and field

Browse Source
This commit is contained in:
Gary Talent 2019-03-17 13:18:46 -05:00
parent bf6469b4a3
commit bbd1d187b2
12 changed files with 145 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
deps/ox/src/ox/mc/read.cpp vendored
View File

@ -27,45 +27,45 @@ MetalClawReader::~MetalClawReader() {
oxAssert(m_field == m_fields, "MetalClawReader: incorrect fields number given");
}
Error MetalClawReader::op(const char*, int8_t *val) {
Error MetalClawReader::field(const char*, int8_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, int16_t *val) {
Error MetalClawReader::field(const char*, int16_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, int32_t *val) {
Error MetalClawReader::field(const char*, int32_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, int64_t *val) {
Error MetalClawReader::field(const char*, int64_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, uint8_t *val) {
Error MetalClawReader::field(const char*, uint8_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, uint16_t *val) {
Error MetalClawReader::field(const char*, uint16_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, uint32_t *val) {
Error MetalClawReader::field(const char*, uint32_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, uint64_t *val) {
Error MetalClawReader::field(const char*, uint64_t *val) {
return readInteger(val);
}
Error MetalClawReader::op(const char*, bool *val) {
Error MetalClawReader::field(const char*, bool *val) {
*val = m_fieldPresence.get(m_field++);
return 0;
}
Error MetalClawReader::op(const char*, SerStr val) {
Error MetalClawReader::field(const char*, SerStr val) {
if (m_fieldPresence.get(m_field++)) {
// read the length
if (m_buffIt >= m_buffLen) {

46
deps/ox/src/ox/mc/read.hpp vendored
View File

@ -37,32 +37,32 @@ class MetalClawReader {
~MetalClawReader();
Error op(const char*, int8_t *val);
Error op(const char*, int16_t *val);
Error op(const char*, int32_t *val);
Error op(const char*, int64_t *val);
Error field(const char*, int8_t *val);
Error field(const char*, int16_t *val);
Error field(const char*, int32_t *val);
Error field(const char*, int64_t *val);
Error op(const char*, uint8_t *val);
Error op(const char*, uint16_t *val);
Error op(const char*, uint32_t *val);
Error op(const char*, uint64_t *val);
Error field(const char*, uint8_t *val);
Error field(const char*, uint16_t *val);
Error field(const char*, uint32_t *val);
Error field(const char*, uint64_t *val);
Error op(const char*, bool *val);
Error field(const char*, bool *val);
// array handler
template<typename T>
Error op(const char*, T *val, std::size_t len);
Error field(const char*, T *val, std::size_t len);
template<typename T>
Error op(const char*, ox::Vector<T> *val);
Error field(const char*, ox::Vector<T> *val);
template<typename T>
Error op(const char*, T *val);
Error field(const char*, T *val);
template<std::size_t L>
Error op(const char*, ox::BString<L> *val);
Error field(const char*, ox::BString<L> *val);
Error op(const char*, SerStr val);
Error field(const char*, SerStr val);
/**
* Reads an array length from the current location in the buffer.
@ -105,18 +105,18 @@ class MetalClawReader {
};
template<typename T>
Error MetalClawReader::op(const char*, T *val) {
Error MetalClawReader::field(const char*, T *val) {
Error err = 0;
if (val && m_fieldPresence.get(m_field++)) {
auto reader = child();
err |= ioOp(&reader, val);
err |= model(&reader, val);
}
return err;
};
template<std::size_t L>
Error MetalClawReader::op(const char *name, ox::BString<L> *val) {
return op(name, SerStr(val->data(), val->cap()));
Error MetalClawReader::field(const char *name, ox::BString<L> *val) {
return field(name, SerStr(val->data(), val->cap()));
}
template<typename I>
@ -138,7 +138,7 @@ Error MetalClawReader::readInteger(I *val) {
// array handler
template<typename T>
Error MetalClawReader::op(const char*, T *val, std::size_t valLen) {
Error MetalClawReader::field(const char*, T *val, std::size_t valLen) {
Error err = 0;
if (m_fieldPresence.get(m_field++)) {
// read the length
@ -155,7 +155,7 @@ Error MetalClawReader::op(const char*, T *val, std::size_t valLen) {
auto reader = child();
reader.setTypeInfo("List", len);
for (std::size_t i = 0; i < len; i++) {
err |= reader.op("", &val[i]);
err |= reader.field("", &val[i]);
}
} else {
err = OxError(MC_OUTBUFFENDED);
@ -165,14 +165,14 @@ Error MetalClawReader::op(const char*, T *val, std::size_t valLen) {
};
template<typename T>
Error MetalClawReader::op(const char*, ox::Vector<T> *val) {
return op(nullptr, val->data(), val->size());
Error MetalClawReader::field(const char*, ox::Vector<T> *val) {
return field(nullptr, val->data(), val->size());
}
template<typename T>
Error readMC(uint8_t *buff, std::size_t buffLen, T *val) {
MetalClawReader reader(buff, buffLen);
return ioOp(&reader, val);
return model(&reader, val);
}
}

58
deps/ox/src/ox/mc/test/tests.cpp vendored
View File

@ -40,33 +40,33 @@ struct TestStruct {
};
template<typename T>
ox::Error ioOp(T *io, TestStructNest *obj) {
ox::Error model(T *io, TestStructNest *obj) {
ox::Error err = 0;
io->setTypeInfo("TestStructNest", 3);
err |= io->op("Bool", &obj->Bool);
err |= io->op("Int", &obj->Int);
err |= io->op("String", &obj->String);
err |= io->field("Bool", &obj->Bool);
err |= io->field("Int", &obj->Int);
err |= io->field("String", &obj->String);
return err;
}
template<typename T>
ox::Error ioOp(T *io, TestStruct *obj) {
ox::Error model(T *io, TestStruct *obj) {
ox::Error err = 0;
io->setTypeInfo("TestStruct", 14);
err |= io->op("Bool", &obj->Bool);
err |= io->op("Int", &obj->Int);
err |= io->op("Int1", &obj->Int1);
err |= io->op("Int2", &obj->Int2);
err |= io->op("Int3", &obj->Int3);
err |= io->op("Int4", &obj->Int4);
err |= io->op("Int5", &obj->Int5);
err |= io->op("Int6", &obj->Int6);
err |= io->op("Int7", &obj->Int7);
err |= io->op("Int8", &obj->Int8);
err |= io->op("String", &obj->String);
err |= io->op("List", obj->List, 4);
err |= io->op("EmptyStruct", &obj->EmptyStruct);
err |= io->op("Struct", &obj->Struct);
err |= io->field("Bool", &obj->Bool);
err |= io->field("Int", &obj->Int);
err |= io->field("Int1", &obj->Int1);
err |= io->field("Int2", &obj->Int2);
err |= io->field("Int3", &obj->Int3);
err |= io->field("Int4", &obj->Int4);
err |= io->field("Int5", &obj->Int5);
err |= io->field("Int6", &obj->Int6);
err |= io->field("Int7", &obj->Int7);
err |= io->field("Int8", &obj->Int8);
err |= io->field("String", &obj->String);
err |= io->field("List", obj->List, 4);
err |= io->field("EmptyStruct", &obj->EmptyStruct);
err |= io->field("Struct", &obj->Struct);
return err;
}
@ -270,25 +270,25 @@ std::map<std::string, ox::Error(*)()> tests = {
switch (f.type->length) {
case 1: {
uint8_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 2: {
uint16_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 4: {
uint32_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 8: {
uint64_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
@ -300,25 +300,25 @@ std::map<std::string, ox::Error(*)()> tests = {
switch (f.type->length) {
case 1: {
int8_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 2: {
int16_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 4: {
int32_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
case 8: {
int64_t i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
std::cout << i;
break;
}
@ -327,14 +327,14 @@ std::map<std::string, ox::Error(*)()> tests = {
break;
case ox::PrimitiveType::Bool: {
bool i = {};
oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
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->op(fieldName, ox::SerStr(v.data(), v.size())), "Walking ioOp failed.");
oxAssert(rdr->field(fieldName, ox::SerStr(v.data(), v.size())), "Walking model failed.");
std::cout << fieldName << ":\t" << "string: " << v.data() << '\n';
break;
}

2
deps/ox/src/ox/mc/walk.hpp vendored
View File

@ -16,7 +16,7 @@ template<typename Reader, typename Handler>
ox::Error walkMC(DescriptorType *type, uint8_t *data, std::size_t dataLen, Handler handler) {
DataWalker<Reader, Handler> walker(type, handler);
Reader rdr(data, dataLen);
return ioOp(&rdr, &walker);
return model(&rdr, &walker);
}
}

20
deps/ox/src/ox/mc/write.cpp vendored
View File

@ -23,44 +23,44 @@ MetalClawWriter::~MetalClawWriter() noexcept {
oxAssert(m_field == m_fields, "MetalClawWriter: incorrect fields number given");
}
Error MetalClawWriter::op(const char*, int8_t *val) {
Error MetalClawWriter::field(const char*, int8_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, int16_t *val) {
Error MetalClawWriter::field(const char*, int16_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, int32_t *val) {
Error MetalClawWriter::field(const char*, int32_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, int64_t *val) {
Error MetalClawWriter::field(const char*, int64_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, uint8_t *val) {
Error MetalClawWriter::field(const char*, uint8_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, uint16_t *val) {
Error MetalClawWriter::field(const char*, uint16_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, uint32_t *val) {
Error MetalClawWriter::field(const char*, uint32_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, uint64_t *val) {
Error MetalClawWriter::field(const char*, uint64_t *val) {
return appendInteger(*val);
}
Error MetalClawWriter::op(const char*, bool *val) {
Error MetalClawWriter::field(const char*, bool *val) {
return m_fieldPresence.set(m_field++, *val);
}
Error MetalClawWriter::op(const char*, SerStr val) {
Error MetalClawWriter::field(const char*, SerStr val) {
int err = 0;
bool fieldSet = false;
if (val.cap()) {

46
deps/ox/src/ox/mc/write.hpp vendored
View File

@ -38,31 +38,31 @@ class MetalClawWriter {
~MetalClawWriter() noexcept;
Error op(const char*, int8_t *val);
Error op(const char*, int16_t *val);
Error op(const char*, int32_t *val);
Error op(const char*, int64_t *val);
Error field(const char*, int8_t *val);
Error field(const char*, int16_t *val);
Error field(const char*, int32_t *val);
Error field(const char*, int64_t *val);
Error op(const char*, uint8_t *val);
Error op(const char*, uint16_t *val);
Error op(const char*, uint32_t *val);
Error op(const char*, uint64_t *val);
Error field(const char*, uint8_t *val);
Error field(const char*, uint16_t *val);
Error field(const char*, uint32_t *val);
Error field(const char*, uint64_t *val);
Error op(const char*, bool *val);
Error field(const char*, bool *val);
template<typename T>
Error op(const char*, T *val, std::size_t len);
Error field(const char*, T *val, std::size_t len);
template<typename T>
Error op(const char*, ox::Vector<T> *val);
Error field(const char*, ox::Vector<T> *val);
template<std::size_t L>
Error op(const char*, ox::BString<L> *val);
Error field(const char*, ox::BString<L> *val);
Error op(const char*, SerStr val);
Error field(const char*, SerStr val);
template<typename T>
Error op(const char*, T *val);
Error field(const char*, T *val);
void setTypeInfo(const char *name, int fields);
@ -78,17 +78,17 @@ class MetalClawWriter {
};
template<std::size_t L>
Error MetalClawWriter::op(const char *name, ox::BString<L> *val) {
return op(name, SerStr(val->data(), val->cap()));
Error MetalClawWriter::field(const char *name, ox::BString<L> *val) {
return field(name, SerStr(val->data(), val->cap()));
}
template<typename T>
Error MetalClawWriter::op(const char*, T *val) {
Error MetalClawWriter::field(const char*, T *val) {
int err = 0;
bool fieldSet = false;
MetalClawWriter writer(m_buff + m_buffIt, m_buffLen - m_buffIt);
if (val) {
err |= ioOp(&writer, val);
err |= model(&writer, val);
if (static_cast<std::size_t>(writer.m_fieldPresence.getMaxLen()) < writer.m_buffIt) {
m_buffIt += writer.m_buffIt;
fieldSet = true;
@ -100,12 +100,12 @@ Error MetalClawWriter::op(const char*, T *val) {
}
template<typename T>
Error MetalClawWriter::op(const char*, ox::Vector<T> *val) {
return op(nullptr, val->data(), val->size());
Error MetalClawWriter::field(const char*, ox::Vector<T> *val) {
return field(nullptr, val->data(), val->size());
}
template<typename T>
Error MetalClawWriter::op(const char*, T *val, std::size_t len) {
Error MetalClawWriter::field(const char*, T *val, std::size_t len) {
Error err = 0;
bool fieldSet = false;
@ -124,7 +124,7 @@ Error MetalClawWriter::op(const char*, T *val, std::size_t len) {
// write the array
for (std::size_t i = 0; i < len; i++) {
err |= writer.op("", &val[i]);
err |= writer.field("", &val[i]);
}
m_buffIt += writer.m_buffIt;
@ -158,7 +158,7 @@ Error MetalClawWriter::appendInteger(I val) {
template<typename T>
Error writeMC(uint8_t *buff, std::size_t buffLen, T *val, std::size_t *sizeOut = nullptr) {
MetalClawWriter writer(buff, buffLen);
auto err = ioOp(&writer, val);
auto err = model(&writer, val);
if (sizeOut) {
*sizeOut = writer.size();
}

2
deps/ox/src/ox/model/descread.hpp vendored
View File

@ -36,7 +36,7 @@ const TypeStore &TypeDescReader<ReaderBase>::typeStore() const {
template<typename ReaderBase, typename T>
int readMCDef(uint8_t *buff, std::size_t buffLen, T *val) {
TypeDescReader<ReaderBase> reader(buff, buffLen);
return ioOp(&reader, val);
return model(&reader, val);
}
}

36
deps/ox/src/ox/model/desctypes.hpp vendored
View File

@ -117,56 +117,56 @@ struct DescriptorType {
template<typename T>
Error ioOp(T *io, DescriptorType *type) {
Error model(T *io, DescriptorType *type) {
Error err = 0;
io->setTypeInfo("ox::DescriptorType", 4);
err |= io->op("typeName", &type->typeName);
err |= io->op("primitiveType", &type->primitiveType);
err |= io->op("fieldList", &type->fieldList);
err |= io->op("length", &type->length);
err |= io->field("typeName", &type->typeName);
err |= io->field("primitiveType", &type->primitiveType);
err |= io->field("fieldList", &type->fieldList);
err |= io->field("length", &type->length);
return err;
}
template<typename T>
Error ioOpWrite(T *io, DescriptorField *field) {
Error modelWrite(T *io, DescriptorField *field) {
Error err = 0;
io->setTypeInfo("ox::DescriptorField", 4);
if (field->ownsType) {
err |= io->op("typeName", "");
err |= io->op("type", field->type);
err |= io->field("typeName", "");
err |= io->field("type", field->type);
} else {
err |= io->op("typeName", &field->type->typeName);
err |= io->op("type", static_cast<decltype(field->type)>(nullptr));
err |= io->field("typeName", &field->type->typeName);
err |= io->field("type", static_cast<decltype(field->type)>(nullptr));
}
err |= io->op("fieldName", &field->fieldName);
err |= io->field("fieldName", &field->fieldName);
// defaultValue is unused now, but leave placeholder for backwards compatibility
const int DefaultValue = 0;
err |= io->op("defaultValue", &DefaultValue);
err |= io->field("defaultValue", &DefaultValue);
return err;
}
template<typename T>
Error ioOpRead(T *io, DescriptorField *field) {
Error modelRead(T *io, DescriptorField *field) {
Error err = 0;
auto &typeStore = io->typeStore();
io->setTypeInfo("ox::DescriptorField", 4);
err |= io->op("typeName", &field->typeName);
err |= io->field("typeName", &field->typeName);
if (field->typeName == "") {
field->ownsType = true;
if (field->type == nullptr) {
field->type = new DescriptorType;
}
err |= io->op("type", field->type);
err |= io->field("type", field->type);
typeStore[field->type->typeName] = field->type;
} else {
// should be empty, so discard
DescriptorType t;
err |= io->op("type", &t);
err |= io->field("type", &t);
field->type = typeStore[field->typeName];
}
err |= io->op("fieldName", &field->fieldName);
err |= io->field("fieldName", &field->fieldName);
// defaultValue is unused now, but placeholder for backwards compatibility
err |= io->op("defaultValue", nullptr);
err |= io->field("defaultValue", nullptr);
return err;
}

28
deps/ox/src/ox/model/descwrite.hpp vendored
View File

@ -43,12 +43,12 @@ class TypeDescWriter {
}
template<typename T>
constexpr ox::Error op(const char*, T*, std::size_t) noexcept {
constexpr ox::Error field(const char*, T*, std::size_t) noexcept {
return OxError(0);
}
template<typename T>
constexpr ox::Error op(const char*, T*) noexcept {
constexpr ox::Error field(const char*, T*) noexcept {
return OxError(0);
}
@ -64,13 +64,13 @@ class TypeDescWriter {
~TypeDescWriter();
template<typename T>
ox::Error op(const char *name, T *val, std::size_t valLen);
ox::Error field(const char *name, T *val, std::size_t valLen);
template<typename T>
ox::Error op(const char *name, ox::Vector<T> *val);
ox::Error field(const char *name, ox::Vector<T> *val);
template<typename T>
ox::Error op(const char *name, T *val);
ox::Error field(const char *name, T *val);
void setTypeInfo(const char *name, int fields);
@ -110,12 +110,12 @@ class TypeDescWriter {
// array handler
template<typename T>
ox::Error TypeDescWriter::op(const char *name, T *val, std::size_t) {
ox::Error TypeDescWriter::field(const char *name, T *val, std::size_t) {
if (m_type) {
constexpr typename ox::remove_pointer<decltype(val)>::type *p = nullptr;
bool alreadyExisted = false;
const auto t = type(p, &alreadyExisted);
oxAssert(t != nullptr, "op(const char *name, T *val, std::size_t): Type not found or generated");
oxAssert(t != nullptr, "field(const char *name, T *val, std::size_t): Type not found or generated");
if (t == nullptr) {
type(p, &alreadyExisted);
}
@ -126,16 +126,16 @@ ox::Error TypeDescWriter::op(const char *name, T *val, std::size_t) {
}
template<typename T>
ox::Error TypeDescWriter::op(const char *name, ox::Vector<T> *val) {
return op(name, val->data(), val->size());
ox::Error TypeDescWriter::field(const char *name, ox::Vector<T> *val) {
return field(name, val->data(), val->size());
}
template<typename T>
ox::Error TypeDescWriter::op(const char *name, T *val) {
ox::Error TypeDescWriter::field(const char *name, T *val) {
if (m_type) {
bool alreadyExisted = false;
const auto t = type(val, &alreadyExisted);
oxAssert(t != nullptr, "op(const char *name, T *val): Type not found or generated");
oxAssert(t != nullptr, "field(const char *name, T *val): Type not found or generated");
m_type->fieldList.emplace_back(t, name, 0, alreadyExisted ? t->typeName : "", !alreadyExisted);
return OxError(0);
}
@ -150,13 +150,13 @@ DescriptorType *TypeDescWriter::type(BString<sz> *val, bool *alreadyExisted) {
template<typename T>
DescriptorType *TypeDescWriter::type(T *val, bool *alreadyExisted) {
NameCatcher nc;
ioOp(&nc, val);
model(&nc, val);
if (m_typeStore->contains(nc.name)) {
*alreadyExisted = true;
return m_typeStore->at(nc.name);
} else {
TypeDescWriter dw(m_typeStore);
oxLogError(ioOp(&dw, val));
oxLogError(model(&dw, val));
*alreadyExisted = false;
return dw.m_type;
}
@ -165,7 +165,7 @@ DescriptorType *TypeDescWriter::type(T *val, bool *alreadyExisted) {
template<typename T>
[[nodiscard]] ValErr<DescriptorType*> buildMCDef(T *val) {
TypeDescWriter writer;
Error err = ioOp(&writer, val);
Error err = model(&writer, val);
return {writer.definition(), err};
}

16
deps/ox/src/ox/model/optype.hpp vendored
View File

@ -18,31 +18,31 @@ enum class OpType {
WriteDefinition = 3,
};
// empty default implementations of ioOp functions
// empty default implementations of model functions
template<typename T, typename O>
ox::Error ioOpRead(T*, O*) {
ox::Error modelRead(T*, O*) {
return OxError(1);
}
template<typename T, typename O>
ox::Error ioOpWrite(T*, O*) {
ox::Error modelWrite(T*, O*) {
return OxError(1);
}
template<typename T, typename O>
ox::Error ioOpWriteDefinition(T*, O*) {
ox::Error modelWriteDefinition(T*, O*) {
return OxError(1);
}
template<typename T, typename O>
ox::Error ioOp(T *io, O *obj) {
ox::Error model(T *io, O *obj) {
if constexpr(T::opType() == ox::OpType::Read) {
return ioOpRead(io, obj);
return modelRead(io, obj);
} else if constexpr(T::opType() == ox::OpType::Write) {
return ioOpWrite(io, obj);
return modelWrite(io, obj);
} else if constexpr(T::opType() == ox::OpType::WriteDefinition) {
return ioOpWriteDefinition(io, obj);
return modelWriteDefinition(io, obj);
}
return OxError(1);
}

6
deps/ox/src/ox/model/walk.hpp vendored
View File

@ -113,13 +113,13 @@ static ox::Error parseField(const DescriptorField &field, Reader *rdr, DataWalke
if (rdr->fieldPresent()) {
auto child = rdr->child();
walker->pushType(field.type);
oxReturnError(ioOp(&child, walker));
oxReturnError(model(&child, walker));
walker->popType();
rdr->nextField();
} else {
// skip and discard absent field
int discard;
oxReturnError(rdr->op("", &discard));
oxReturnError(rdr->field("", &discard));
}
break;
}
@ -129,7 +129,7 @@ static ox::Error parseField(const DescriptorField &field, Reader *rdr, DataWalke
}
template<typename Reader, typename FH>
ox::Error ioOp(Reader *rdr, DataWalker<Reader, FH> *walker) {
ox::Error model(Reader *rdr, DataWalker<Reader, FH> *walker) {
auto type = walker->type();
if (!type) {
return OxError(1);

10
deps/ox/src/ox/std/trace.hpp vendored
View File

@ -21,13 +21,13 @@ struct TraceMsg {
};
template<typename T>
int ioOp(T *io, ox::trace::TraceMsg *obj) {
int model(T *io, ox::trace::TraceMsg *obj) {
int32_t err = 0;
io->setTypeInfo("ox::trace::TraceMsg", 5);
err |= io->op("file", &obj->file);
err |= io->op("line", &obj->line);
err |= io->op("time", &obj->time);
err |= io->op("msg", &obj->msg);
err |= io->field("file", &obj->file);
err |= io->field("line", &obj->line);
err |= io->field("time", &obj->time);
err |= io->field("msg", &obj->msg);
return err;
}