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

[ox] Cleanup
All checks were successful
Build / build (push) Successful in 1m9s
Details

Browse Source
This commit is contained in:
Gary Talent
2026-01-25 23:33:00 -06:00
parent 0e028ff653
commit 53aea9731d
11 changed files with 349 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
deps/ox/src/ox/claw/read.cpp vendored
View File

@@ -106,15 +106,14 @@ Result<ModelObject> readClaw(TypeStore &ts, BufferView buff) noexcept {
{ {
ox::BufferReader br({header.data, header.dataSize}); ox::BufferReader br({header.data, header.dataSize});
MetalClawReader reader(br); MetalClawReader reader(br);
ModelHandlerInterface handler(&reader); OX_RETURN_ERROR(model(reader.interface(), &obj));
OX_RETURN_ERROR(model(&handler, &obj));
return obj; return obj;
} }
case ClawFormat::Organic: case ClawFormat::Organic:
{ {
#ifdef OX_USE_STDLIB #ifdef OX_USE_STDLIB
OrganicClawReader reader({header.data, header.dataSize}); OrganicClawReader reader({header.data, header.dataSize});
ModelHandlerInterface handler(&reader); ModelHandlerInterface handler(reader);
OX_RETURN_ERROR(model(&handler, &obj)); OX_RETURN_ERROR(model(&handler, &obj));
return obj; return obj;
#else #else

3
deps/ox/src/ox/claw/read.hpp vendored
View File

@@ -52,8 +52,7 @@ Error readClaw(ox::BufferView buff, T &val) {
{ {
ox::BufferReader br({header.data, header.dataSize}); ox::BufferReader br({header.data, header.dataSize});
MetalClawReader reader(br); MetalClawReader reader(br);
ModelHandlerInterface handler(&reader); return model(reader.interface(), &val);
return model(&handler, &val);
} }
case ClawFormat::Organic: case ClawFormat::Organic:
{ {

8
deps/ox/src/ox/mc/intops.hpp vendored
View File

@@ -139,19 +139,19 @@ static_assert(countBytes(0b0111'1111) == 8);
static_assert(countBytes(0b1111'1111) == 9); static_assert(countBytes(0b1111'1111) == 9);
template<typename I> template<typename I>
constexpr Result<I> decodeInteger(Reader_c auto&rdr, std::size_t *bytesRead) noexcept { constexpr Result<I> decodeInteger(Reader_c auto&rdr, std::size_t &bytesRead) noexcept {
uint8_t firstByte = 0; uint8_t firstByte = 0;
OX_RETURN_ERROR(rdr.read(&firstByte, 1)); OX_RETURN_ERROR(rdr.read(&firstByte, 1));
OX_RETURN_ERROR(rdr.seekg(-1, ox::ios_base::cur)); OX_RETURN_ERROR(rdr.seekg(-1, ox::ios_base::cur));
const auto bytes = countBytes(firstByte); const auto bytes = countBytes(firstByte);
if (bytes == 9) { if (bytes == 9) {
*bytesRead = bytes; bytesRead = bytes;
I out = 0; I out = 0;
OX_RETURN_ERROR(rdr.seekg(1, ox::ios_base::cur)); OX_RETURN_ERROR(rdr.seekg(1, ox::ios_base::cur));
OX_RETURN_ERROR(rdr.read(&out, sizeof(I))); OX_RETURN_ERROR(rdr.read(&out, sizeof(I)));
return fromLittleEndian<I>(out); return fromLittleEndian<I>(out);
} }
*bytesRead = bytes; bytesRead = bytes;
uint64_t decoded = 0; uint64_t decoded = 0;
OX_RETURN_ERROR(rdr.read(&decoded, bytes)); OX_RETURN_ERROR(rdr.read(&decoded, bytes));
decoded >>= bytes; decoded >>= bytes;
@@ -196,7 +196,7 @@ template<typename I>
Result<I> decodeInteger(McInt m) noexcept { Result<I> decodeInteger(McInt m) noexcept {
std::size_t bytesRead{}; std::size_t bytesRead{};
BufferReader br({reinterpret_cast<const char*>(m.data.data()), 9}); BufferReader br({reinterpret_cast<const char*>(m.data.data()), 9});
return decodeInteger<I>(br, &bytesRead); return decodeInteger<I>(br, bytesRead);
} }
} }

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

@@ -32,58 +32,58 @@ class MetalClawReaderTemplate: public ModelHandlerBase<MetalClawReaderTemplate<R
private: private:
FieldBitmapReader<Reader> m_fieldPresence; FieldBitmapReader<Reader> m_fieldPresence;
std::size_t m_fields = 0; size_t m_fields{};
std::size_t m_field = 0; size_t m_field{};
ox::Optional<int> m_unionIdx; Optional<int> const m_unionIdx{};
Reader &m_reader; Reader &m_reader;
public: public:
explicit constexpr MetalClawReaderTemplate( explicit constexpr MetalClawReaderTemplate(
Reader &reader, Reader &reader,
ox::Optional<int> const&unionIdx = {}) noexcept; Optional<int> const &unionIdx = {}) noexcept;
constexpr ~MetalClawReaderTemplate() noexcept; constexpr ~MetalClawReaderTemplate() noexcept;
constexpr Error field(const char*, int8_t *val) noexcept; constexpr Error field(CString, int8_t *val) noexcept;
constexpr Error field(const char*, int16_t *val) noexcept; constexpr Error field(CString, int16_t *val) noexcept;
constexpr Error field(const char*, int32_t *val) noexcept; constexpr Error field(CString, int32_t *val) noexcept;
constexpr Error field(const char*, int64_t *val) noexcept; constexpr Error field(CString, int64_t *val) noexcept;
constexpr Error field(const char*, uint8_t *val) noexcept; constexpr Error field(CString, uint8_t *val) noexcept;
constexpr Error field(const char*, uint16_t *val) noexcept; constexpr Error field(CString, uint16_t *val) noexcept;
constexpr Error field(const char*, uint32_t *val) noexcept; constexpr Error field(CString, uint32_t *val) noexcept;
constexpr Error field(const char*, uint64_t *val) noexcept; constexpr Error field(CString, uint64_t *val) noexcept;
constexpr Error field(const char*, bool *val) noexcept; constexpr Error field(CString, bool *val) noexcept;
// array handler // array handler
constexpr Error field(const char*, auto *val, std::size_t len) noexcept; constexpr Error field(CString, auto *val, size_t valLen) noexcept;
// map handler // map handler
template<typename T> template<typename T>
constexpr Error field(const char*, HashMap<String, T> *val) noexcept; constexpr Error field(CString, HashMap<String, T> *val) noexcept;
// array handler, with callback to allow handling individual elements // array handler, with callback to allow handling individual elements
template<typename T, typename CB> template<typename T, typename CB>
constexpr Error field(const char*, CB cb) noexcept; constexpr Error field(CString, CB cb) noexcept;
template<typename T> template<typename T>
constexpr Error field(const char*, T *val) noexcept; constexpr Error field(CString, T *val) noexcept;
template<typename U, bool force> template<typename U, bool force>
constexpr Error field(const char*, UnionView<U, force> val) noexcept; constexpr Error field(CString, UnionView<U, force> val) noexcept;
template<std::size_t SmallStringSize> template<size_t SmallStringSize>
constexpr Error field(const char*, BasicString<SmallStringSize> *val) noexcept; constexpr Error field(CString, BasicString<SmallStringSize> *val) noexcept;
template<std::size_t L> template<size_t L>
constexpr Error field(const char*, IString<L> *val) noexcept; constexpr Error field(CString, IString<L> *val) noexcept;
constexpr Error fieldCString(const char*, char *val, std::size_t buffLen) noexcept; constexpr Error fieldCString(CString, char *val, size_t buffLen) noexcept;
constexpr Error fieldCString(const char*, char **val) noexcept; constexpr Error fieldCString(CString, char **val) noexcept;
constexpr Error fieldCString(const char*, char **val, std::size_t buffLen) noexcept; constexpr Error fieldCString(CString, char **val, size_t buffLen) noexcept;
/** /**
* Reads an array length from the current location in the buffer. * Reads an array length from the current location in the buffer.
@@ -101,13 +101,13 @@ class MetalClawReaderTemplate: public ModelHandlerBase<MetalClawReaderTemplate<R
const char *name = T::TypeName, const char *name = T::TypeName,
int version = T::TypeVersion, int version = T::TypeVersion,
const Vector<String>& = {}, const Vector<String>& = {},
std::size_t fields = ModelFieldCount_v<T>) noexcept; size_t fields = ModelFieldCount_v<T>) noexcept;
/** /**
* Returns a MetalClawReader to parse a child object. * Returns a MetalClawReader to parse a child object.
*/ */
[[nodiscard]] [[nodiscard]]
constexpr MetalClawReaderTemplate<Reader> child(const char *name, ox::Optional<int> unionIdx = {}) noexcept; constexpr MetalClawReaderTemplate<Reader> child(const char *name, Optional<int> unionIdx = {}) noexcept;
/** /**
* Indicates whether or not the next field to be read is present. * Indicates whether or not the next field to be read is present.
@@ -122,20 +122,20 @@ class MetalClawReaderTemplate: public ModelHandlerBase<MetalClawReaderTemplate<R
constexpr bool fieldPresent(int fieldNo) const noexcept; constexpr bool fieldPresent(int fieldNo) const noexcept;
[[nodiscard]] [[nodiscard]]
constexpr int whichFieldPresent(const char *name, const ModelUnion&) const noexcept; constexpr int whichFieldPresent(const char *name, ModelUnion const&) const noexcept;
constexpr void nextField() noexcept; constexpr void nextField() noexcept;
private: private:
template<typename I> template<typename I>
constexpr Error readInteger(I *val) noexcept; constexpr Error readInteger(I &val) noexcept;
}; };
template<Reader_c Reader> template<Reader_c Reader>
constexpr MetalClawReaderTemplate<Reader>::MetalClawReaderTemplate( constexpr MetalClawReaderTemplate<Reader>::MetalClawReaderTemplate(
Reader &reader, Reader &reader,
ox::Optional<int> const&unionIdx) noexcept: Optional<int> const &unionIdx) noexcept:
m_fieldPresence(reader), m_fieldPresence(reader),
m_unionIdx(unionIdx), m_unionIdx(unionIdx),
m_reader(reader) { m_reader(reader) {
@@ -149,50 +149,50 @@ constexpr MetalClawReaderTemplate<Reader>::~MetalClawReaderTemplate() noexcept {
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int8_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int8_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int16_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int16_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int32_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int32_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int64_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int64_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint8_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint8_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint16_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint16_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint32_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint32_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint64_t *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint64_t *val) noexcept {
return readInteger(val); return readInteger(*val);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, bool *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, bool *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
auto const result = m_fieldPresence.get(static_cast<std::size_t>(m_field)); auto const result = m_fieldPresence.get(static_cast<size_t>(m_field));
*val = result.value; *val = result.value;
OX_RETURN_ERROR(result); OX_RETURN_ERROR(result);
} }
@@ -202,18 +202,19 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, bool *val) n
// array handler // array handler
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, auto *val, std::size_t valLen) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { const char *name, auto *val, size_t const valLen) noexcept {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead)); OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, bytesRead));
// read the list // read the list
if (valLen >= len) { if (valLen >= len) {
auto reader = child({}); auto reader = child({});
auto &handler = *reader.interface(); auto &handler = *reader.interface();
OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len))); OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<size_t>(len)));
for (std::size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_ALLOW_UNSAFE_BUFFERS_BEGIN
OX_RETURN_ERROR(handler.field({}, &val[i])); OX_RETURN_ERROR(handler.field({}, &val[i]));
OX_ALLOW_UNSAFE_BUFFERS_END OX_ALLOW_UNSAFE_BUFFERS_END
@@ -230,18 +231,18 @@ OX_ALLOW_UNSAFE_BUFFERS_END
template<Reader_c Reader> template<Reader_c Reader>
template<typename T> template<typename T>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, HashMap<String, T> *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, HashMap<String, T> *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
OX_REQUIRE(g, m_reader.tellg()); OX_REQUIRE(g, m_reader.tellg());
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead)); OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, bytesRead));
OX_RETURN_ERROR(m_reader.seekg(g)); OX_RETURN_ERROR(m_reader.seekg(g));
// read the list // read the list
auto reader = child(""); auto reader = child("");
auto &handler = *reader.interface(); auto &handler = *reader.interface();
OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len))); OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<size_t>(len)));
// this loop body needs to be in a lambda because of the potential alloca call // this loop body needs to be in a lambda because of the potential alloca call
constexpr auto loopBody = [](auto &handler, auto &val) { constexpr auto loopBody = [](auto &handler, auto &val) {
OX_REQUIRE(keyLen, handler.stringLength(nullptr)); OX_REQUIRE(keyLen, handler.stringLength(nullptr));
@@ -250,7 +251,7 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, HashMap<Stri
OX_RETURN_ERROR(handler.fieldCString("", &wkeyPtr, keyLen + 1)); OX_RETURN_ERROR(handler.fieldCString("", &wkeyPtr, keyLen + 1));
return handler.field("", &val[wkeyPtr]); return handler.field("", &val[wkeyPtr]);
}; };
for (std::size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
OX_RETURN_ERROR(loopBody(handler, *val)); OX_RETURN_ERROR(loopBody(handler, *val));
} }
} }
@@ -263,9 +264,9 @@ template<Reader_c Reader>
template<typename T> template<typename T>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val) noexcept {
if constexpr(isVector_v<T>) { if constexpr(isVector_v<T>) {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
// set size of val if the field is present, don't worry about it if not // set size of val if the field is present, don't worry about it if not
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
OX_REQUIRE(len, arrayLength(name, false)); OX_REQUIRE(len, arrayLength(name, false));
OX_RETURN_ERROR(ox::resizeVector(*val, len)); OX_RETURN_ERROR(ox::resizeVector(*val, len));
return field(name, val->data(), val->size()); return field(name, val->data(), val->size());
@@ -275,9 +276,9 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val)
++m_field; ++m_field;
return {}; return {};
} else if constexpr(isArray_v<T>) { } else if constexpr(isArray_v<T>) {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
// set size of val if the field is present, don't worry about it if not // set size of val if the field is present, don't worry about it if not
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
OX_REQUIRE(len, arrayLength(name, false)); OX_REQUIRE(len, arrayLength(name, false));
if (len > val->size()) { if (len > val->size()) {
return ox::Error(1, "Input array is too long"); return ox::Error(1, "Input array is too long");
@@ -288,8 +289,8 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val)
++m_field; ++m_field;
return {}; return {};
} else { } else {
if ((!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) && val) { if ((!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) && val) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
auto reader = child(""); auto reader = child("");
OX_RETURN_ERROR(model(reader.interface(), val)); OX_RETURN_ERROR(model(reader.interface(), val));
} }
@@ -301,9 +302,9 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val)
template<Reader_c Reader> template<Reader_c Reader>
template<typename U, bool force> template<typename U, bool force>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, UnionView<U, force> val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, UnionView<U, force> val) noexcept {
if ((!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) && val.get()) { if ((!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) && val.get()) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
auto reader = child("", ox::Optional<int>(ox::in_place, val.idx())); auto reader = child("", ox::Optional<int>(ox::in_place, val.idx()));
OX_RETURN_ERROR(model(reader.interface(), val.get())); OX_RETURN_ERROR(model(reader.interface(), val.get()));
} }
@@ -313,13 +314,13 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, UnionView<U,
} }
template<Reader_c Reader> template<Reader_c Reader>
template<std::size_t SmallStringSize> template<size_t SmallStringSize>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, BasicString<SmallStringSize> *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, BasicString<SmallStringSize> *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead)); OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
const auto cap = size; const auto cap = size;
*val = BasicString<SmallStringSize>(cap); *val = BasicString<SmallStringSize>(cap);
auto data = val->data(); auto data = val->data();
@@ -334,13 +335,13 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, BasicString<
} }
template<Reader_c Reader> template<Reader_c Reader>
template<std::size_t L> template<size_t L>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, IString<L> *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, IString<L> *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead)); OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
*val = IString<L>(); *val = IString<L>();
OX_RETURN_ERROR(val->resize(size)); OX_RETURN_ERROR(val->resize(size));
auto const data = val->data(); auto const data = val->data();
@@ -355,11 +356,12 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, IString<L> *
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char *val, std::size_t buffLen) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { CString, char *val, size_t const buffLen) noexcept {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead)); OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
if (size > buffLen) { if (size > buffLen) {
return ox::Error(McOutputBuffEnded); return ox::Error(McOutputBuffEnded);
} }
@@ -374,11 +376,11 @@ constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char **val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(CString, char **val) noexcept {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead)); OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
// re-allocate in case too small // re-allocate in case too small
safeDelete(*val); safeDelete(*val);
*val = new char[size + 1]; *val = new char[size + 1];
@@ -392,12 +394,12 @@ constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char **val, std::size_t buffLen) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(CString, char **val, size_t buffLen) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead)); OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
// re-allocate if too small // re-allocate if too small
if (buffLen < size + 1) { if (buffLen < size + 1) {
safeDelete(*val); safeDelete(*val);
@@ -420,13 +422,13 @@ constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(const char*, bool pass) noexcept { constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(CString, bool const pass) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(g, m_reader.tellg()); OX_REQUIRE(g, m_reader.tellg());
OX_REQUIRE(out, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead)); OX_REQUIRE(out, mc::decodeInteger<ArrayLength>(m_reader, bytesRead));
if (!pass) { if (!pass) {
OX_RETURN_ERROR(m_reader.seekg(g)); OX_RETURN_ERROR(m_reader.seekg(g));
} }
@@ -437,12 +439,12 @@ constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(const
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(const char*) noexcept { constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(CString) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
auto len = mc::decodeInteger<StringLength>(m_reader, &bytesRead); auto len = mc::decodeInteger<StringLength>(m_reader, bytesRead);
OX_RETURN_ERROR(m_reader.seekg(-static_cast<int64_t>(bytesRead), ox::ios_base::cur)); OX_RETURN_ERROR(m_reader.seekg(-static_cast<int64_t>(bytesRead), ox::ios_base::cur));
return len; return len;
} }
@@ -452,15 +454,15 @@ constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(con
template<Reader_c Reader> template<Reader_c Reader>
template<typename I> template<typename I>
constexpr Error MetalClawReaderTemplate<Reader>::readInteger(I *val) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::readInteger(I &val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
std::size_t bytesRead = 0; size_t bytesRead = 0;
auto const result = mc::decodeInteger<I>(m_reader, &bytesRead); auto const result = mc::decodeInteger<I>(m_reader, bytesRead);
OX_RETURN_ERROR(result); OX_RETURN_ERROR(result);
*val = result.value; val = result.value;
} else { } else {
*val = 0; val = 0;
} }
} }
++m_field; ++m_field;
@@ -469,17 +471,17 @@ constexpr Error MetalClawReaderTemplate<Reader>::readInteger(I *val) noexcept {
template<Reader_c Reader> template<Reader_c Reader>
template<typename T, typename CB> template<typename T, typename CB>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, CB cb) noexcept { constexpr Error MetalClawReaderTemplate<Reader>::field(CString, CB cb) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) { if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) { if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length // read the length
std::size_t bytesRead = 0; size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead)); OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, bytesRead));
// read the list // read the list
auto reader = child(""); auto reader = child("");
auto &handler = *reader.interface(); auto &handler = *reader.interface();
OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len))); OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<size_t>(len)));
for (std::size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
T val; T val;
OX_RETURN_ERROR(handler.field("", &val)); OX_RETURN_ERROR(handler.field("", &val));
OX_RETURN_ERROR(cb(i, &val)); OX_RETURN_ERROR(cb(i, &val));
@@ -493,7 +495,7 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, CB cb) noexc
template<Reader_c Reader> template<Reader_c Reader>
template<typename T> template<typename T>
constexpr ox::Error MetalClawReaderTemplate<Reader>::setTypeInfo( constexpr ox::Error MetalClawReaderTemplate<Reader>::setTypeInfo(
const char*, int, const Vector<String>&, std::size_t fields) noexcept { CString, int, const Vector<String>&, size_t const fields) noexcept {
m_fields = fields; m_fields = fields;
// Warning: narrow-conv // Warning: narrow-conv
return m_reader.seekg( return m_reader.seekg(
@@ -503,24 +505,24 @@ constexpr ox::Error MetalClawReaderTemplate<Reader>::setTypeInfo(
template<Reader_c Reader> template<Reader_c Reader>
constexpr MetalClawReaderTemplate<Reader> MetalClawReaderTemplate<Reader>::child( constexpr MetalClawReaderTemplate<Reader> MetalClawReaderTemplate<Reader>::child(
const char*, CString,
ox::Optional<int> unionIdx) noexcept { Optional<int> const unionIdx) noexcept {
return MetalClawReaderTemplate<Reader>(m_reader, unionIdx); return MetalClawReaderTemplate<Reader>(m_reader, unionIdx);
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(const char*) const noexcept { constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(CString) const noexcept {
return m_fieldPresence.get(static_cast<std::size_t>(m_field)).value; return m_fieldPresence.get(static_cast<size_t>(m_field)).value;
} }
template<Reader_c Reader> template<Reader_c Reader>
constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(int fieldNo) const noexcept { constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(int const fieldNo) const noexcept {
return m_fieldPresence.get(static_cast<std::size_t>(fieldNo)).value; return m_fieldPresence.get(static_cast<size_t>(fieldNo)).value;
} }
template<Reader_c Reader> template<Reader_c Reader>
[[nodiscard]] [[nodiscard]]
constexpr int MetalClawReaderTemplate<Reader>::whichFieldPresent(const char*, const ModelUnion &u) const noexcept { constexpr int MetalClawReaderTemplate<Reader>::whichFieldPresent(CString, ModelUnion const &u) const noexcept {
FieldBitmapReader<Reader> p(m_reader); FieldBitmapReader<Reader> p(m_reader);
for (auto i = 0u; i < u.fieldCount(); ++i) { for (auto i = 0u; i < u.fieldCount(); ++i) {
if (p.get(i)) { if (p.get(i)) {
@@ -538,11 +540,10 @@ constexpr void MetalClawReaderTemplate<Reader>::nextField() noexcept {
using MetalClawReader = MetalClawReaderTemplate<ox::BufferReader>; using MetalClawReader = MetalClawReaderTemplate<ox::BufferReader>;
template<typename T> template<typename T>
Error readMC(ox::BufferView buff, T &val) noexcept { Error readMC(ox::BufferView const buff, T &val) noexcept {
BufferReader br(buff); BufferReader br(buff);
MetalClawReader reader(br); MetalClawReader reader(br);
ModelHandlerInterface<MetalClawReader, ox::OpType::Read> handler(&reader); return model(reader.interface(), &val);
return model(&handler, &val);
} }
template<typename T> template<typename T>

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

@@ -268,7 +268,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val) noexce
if (val && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) { if (val && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
auto const writeIdx = m_writer.tellp(); auto const writeIdx = m_writer.tellp();
MetalClawWriter<Writer> writer(m_writer); MetalClawWriter<Writer> writer(m_writer);
ModelHandlerInterface<MetalClawWriter<Writer>> handler{&writer}; ModelHandlerInterface<MetalClawWriter<Writer>> handler{writer};
OX_RETURN_ERROR(model(&handler, val)); OX_RETURN_ERROR(model(&handler, val));
OX_RETURN_ERROR(writer.finalize()); OX_RETURN_ERROR(writer.finalize());
fieldSet = writeIdx != m_writer.tellp(); fieldSet = writeIdx != m_writer.tellp();
@@ -286,7 +286,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, UnionView<U, force>
if (val.get() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) { if (val.get() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
auto const writeIdx = m_writer.tellp(); auto const writeIdx = m_writer.tellp();
MetalClawWriter<Writer> writer(m_writer, ox::Optional<int>(ox::in_place, val.idx())); MetalClawWriter<Writer> writer(m_writer, ox::Optional<int>(ox::in_place, val.idx()));
ModelHandlerInterface handler{&writer}; ModelHandlerInterface handler{writer};
OX_RETURN_ERROR(model(&handler, val.get())); OX_RETURN_ERROR(model(&handler, val.get()));
OX_RETURN_ERROR(writer.finalize()); OX_RETURN_ERROR(writer.finalize());
fieldSet = writeIdx != m_writer.tellp(); fieldSet = writeIdx != m_writer.tellp();
@@ -306,7 +306,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val, std::s
OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(arrLen.data.data()), arrLen.length)); OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(arrLen.data.data()), arrLen.length));
auto const writeIdx = m_writer.tellp(); auto const writeIdx = m_writer.tellp();
MetalClawWriter<Writer> writer(m_writer); MetalClawWriter<Writer> writer(m_writer);
ModelHandlerInterface handler{&writer}; ModelHandlerInterface handler{writer};
OX_RETURN_ERROR(handler.template setTypeInfo<T>("List", 0, {}, static_cast<std::size_t>(len))); OX_RETURN_ERROR(handler.template setTypeInfo<T>("List", 0, {}, static_cast<std::size_t>(len)));
// write the array // write the array
for (std::size_t i = 0; i < len; ++i) { for (std::size_t i = 0; i < len; ++i) {
@@ -334,7 +334,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(arrLen.data.data()), arrLen.length)); OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(arrLen.data.data()), arrLen.length));
// write map // write map
MetalClawWriter<Writer> writer(m_writer); MetalClawWriter<Writer> writer(m_writer);
ModelHandlerInterface handler{&writer}; ModelHandlerInterface handler{writer};
// double len for both key and value // double len for both key and value
OX_RETURN_ERROR(handler.setTypeInfo("Map", 0, {}, len * 2)); OX_RETURN_ERROR(handler.setTypeInfo("Map", 0, {}, len * 2));
// this loop body needs to be in a lambda because of the potential alloca call // this loop body needs to be in a lambda because of the potential alloca call
@@ -387,7 +387,7 @@ ox::Error MetalClawWriter<Writer>::finalize() noexcept {
Result<Buffer> writeMC(Writer_c auto &writer, const auto &val) noexcept { Result<Buffer> writeMC(Writer_c auto &writer, const auto &val) noexcept {
MetalClawWriter mcWriter(writer); MetalClawWriter mcWriter(writer);
ModelHandlerInterface handler{&mcWriter}; ModelHandlerInterface handler{mcWriter};
OX_RETURN_ERROR(model(&handler, &val)); OX_RETURN_ERROR(model(&handler, &val));
OX_RETURN_ERROR(mcWriter.finalize()); OX_RETURN_ERROR(mcWriter.finalize());
return {}; return {};

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

@@ -380,7 +380,7 @@ constexpr const DescriptorType *TypeDescWriter::getType(StringViewCR tn, int typ
template<typename T> template<typename T>
constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore) noexcept { constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore) noexcept {
TypeDescWriter writer(&typeStore); TypeDescWriter writer(&typeStore);
ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(&writer); ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(writer);
if (std::is_constant_evaluated()) { if (std::is_constant_evaluated()) {
std::allocator<T> a; std::allocator<T> a;
T *t = a.allocate(1); T *t = a.allocate(1);
@@ -396,7 +396,7 @@ constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore) noexcept {
template<typename T> template<typename T>
constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore, T &val) noexcept { constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore, T &val) noexcept {
TypeDescWriter writer(&typeStore); TypeDescWriter writer(&typeStore);
ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(&writer); ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(writer);
OX_RETURN_ERROR(model(&handler, &val)); OX_RETURN_ERROR(model(&handler, &val));
return writer.definition(); return writer.definition();
} }

80
deps/ox/src/ox/model/modelhandleradaptor.hpp vendored
View File

@@ -17,10 +17,10 @@ namespace ox {
template<typename Handler, OpType opType_v = Handler::opType()> template<typename Handler, OpType opType_v = Handler::opType()>
class ModelHandlerInterface { class ModelHandlerInterface {
private: private:
Handler *m_handler = nullptr; Handler &m_handler;
public: public:
constexpr explicit ModelHandlerInterface(Handler *handler) noexcept: m_handler(handler) { constexpr explicit ModelHandlerInterface(Handler &handler) noexcept: m_handler(handler) {
} }
template<typename T = std::nullptr_t> template<typename T = std::nullptr_t>
@@ -28,7 +28,7 @@ class ModelHandlerInterface {
const char* name = T::TypeName, const char* name = T::TypeName,
int version = T::TypeVersion, int version = T::TypeVersion,
const Vector<String>& typeParams = {}) noexcept { const Vector<String>& typeParams = {}) noexcept {
return m_handler->template setTypeInfo<T>(name, version, typeParams, ModelFieldCount_v<T>); return m_handler.template setTypeInfo<T>(name, version, typeParams, ModelFieldCount_v<T>);
} }
template<typename T = std::nullptr_t> template<typename T = std::nullptr_t>
@@ -37,31 +37,31 @@ class ModelHandlerInterface {
int version, int version,
const Vector<String>& typeParams, const Vector<String>& typeParams,
std::size_t fields) noexcept { std::size_t fields) noexcept {
return m_handler->template setTypeInfo<T>(name, version, typeParams, fields); return m_handler.template setTypeInfo<T>(name, version, typeParams, fields);
} }
template<std::size_t len> template<std::size_t len>
constexpr Error fieldCString(const char *name, char val[len]) noexcept { constexpr Error fieldCString(const char *name, char val[len]) noexcept {
return m_handler->fieldCString(name, &val[0], len); return m_handler.fieldCString(name, &val[0], len);
} }
template<std::size_t len> template<std::size_t len>
constexpr Error fieldCString(const char *name, const char val[len]) noexcept requires(opType_v != OpType::Read) { constexpr Error fieldCString(const char *name, const char val[len]) noexcept requires(opType_v != OpType::Read) {
if constexpr(opType_v != OpType::Read) { if constexpr(opType_v != OpType::Read) {
return m_handler->fieldCString(name, &val[0], len); return m_handler.fieldCString(name, &val[0], len);
} else { } else {
return {}; return {};
} }
} }
constexpr Error fieldCString(const char *name, char **val) noexcept { constexpr Error fieldCString(const char *name, char **val) noexcept {
return m_handler->fieldCString(name, val); return m_handler.fieldCString(name, val);
} }
constexpr Error fieldCString(const char *name, const char *const*val) noexcept requires(opType_v != OpType::Read) { constexpr Error fieldCString(const char *name, const char *const*val) noexcept requires(opType_v != OpType::Read) {
// this check looks pointless, but it's to address a Clang bug // this check looks pointless, but it's to address a Clang bug
if constexpr(opType_v != OpType::Read) { if constexpr(opType_v != OpType::Read) {
return m_handler->fieldCString(name, val); return m_handler.fieldCString(name, val);
} else { } else {
return {}; return {};
} }
@@ -70,27 +70,27 @@ class ModelHandlerInterface {
constexpr Error fieldCString(const char *name, const char **val) noexcept requires(opType_v != OpType::Read) { constexpr Error fieldCString(const char *name, const char **val) noexcept requires(opType_v != OpType::Read) {
// this check looks pointless, but it's to address a Clang bug // this check looks pointless, but it's to address a Clang bug
if constexpr(opType_v != OpType::Read) { if constexpr(opType_v != OpType::Read) {
return m_handler->fieldCString(name, val); return m_handler.fieldCString(name, val);
} else { } else {
return {}; return {};
} }
} }
constexpr Error fieldCString(const char *name, char **val, std::size_t buffLen) noexcept { constexpr Error fieldCString(const char *name, char **val, std::size_t buffLen) noexcept {
return m_handler->fieldCString(name, val, buffLen); return m_handler.fieldCString(name, val, buffLen);
} }
constexpr Error fieldCString(const char *name, const char **val, std::size_t buffLen) noexcept requires(opType_v != OpType::Read) { constexpr Error fieldCString(const char *name, const char **val, std::size_t buffLen) noexcept requires(opType_v != OpType::Read) {
// this check looks pointless, but it's to address a Clang bug // this check looks pointless, but it's to address a Clang bug
if constexpr(opType_v != OpType::Read) { if constexpr(opType_v != OpType::Read) {
return m_handler->fieldCString(name, val, buffLen); return m_handler.fieldCString(name, val, buffLen);
} else { } else {
return {}; return {};
} }
} }
constexpr Error fieldCString(const char *name, char *val, std::size_t buffLen) noexcept { constexpr Error fieldCString(const char *name, char *val, std::size_t buffLen) noexcept {
return m_handler->fieldCString(name, val, buffLen); return m_handler.fieldCString(name, val, buffLen);
} }
constexpr Error fieldModelValue(const char *name, CommonPtrWith<ModelValue> auto *v) noexcept { constexpr Error fieldModelValue(const char *name, CommonPtrWith<ModelValue> auto *v) noexcept {
@@ -98,41 +98,41 @@ class ModelHandlerInterface {
case ModelValue::Type::Undefined: case ModelValue::Type::Undefined:
break; break;
case ModelValue::Type::Bool: case ModelValue::Type::Bool:
return m_handler->field(name, &v->template get<bool>()); return m_handler.field(name, &v->template get<bool>());
case ModelValue::Type::UnsignedInteger8: case ModelValue::Type::UnsignedInteger8:
return m_handler->field(name, &v->template get<uint8_t>()); return m_handler.field(name, &v->template get<uint8_t>());
case ModelValue::Type::UnsignedInteger16: case ModelValue::Type::UnsignedInteger16:
return m_handler->field(name, &v->template get<uint16_t>()); return m_handler.field(name, &v->template get<uint16_t>());
case ModelValue::Type::UnsignedInteger32: case ModelValue::Type::UnsignedInteger32:
return m_handler->field(name, &v->template get<uint32_t>()); return m_handler.field(name, &v->template get<uint32_t>());
case ModelValue::Type::UnsignedInteger64: case ModelValue::Type::UnsignedInteger64:
return m_handler->field(name, &v->template get<uint64_t>()); return m_handler.field(name, &v->template get<uint64_t>());
case ModelValue::Type::SignedInteger8: case ModelValue::Type::SignedInteger8:
return m_handler->field(name, &v->template get<int8_t>()); return m_handler.field(name, &v->template get<int8_t>());
case ModelValue::Type::SignedInteger16: case ModelValue::Type::SignedInteger16:
return m_handler->field(name, &v->template get<int16_t>()); return m_handler.field(name, &v->template get<int16_t>());
case ModelValue::Type::SignedInteger32: case ModelValue::Type::SignedInteger32:
return m_handler->field(name, &v->template get<int32_t>()); return m_handler.field(name, &v->template get<int32_t>());
case ModelValue::Type::SignedInteger64: case ModelValue::Type::SignedInteger64:
return m_handler->field(name, &v->template get<int64_t>()); return m_handler.field(name, &v->template get<int64_t>());
case ModelValue::Type::String: case ModelValue::Type::String:
return m_handler->field(name, &v->template get<String>()); return m_handler.field(name, &v->template get<String>());
case ModelValue::Type::Object: case ModelValue::Type::Object:
return m_handler->field(name, &v->template get<ModelObject>()); return m_handler.field(name, &v->template get<ModelObject>());
case ModelValue::Type::Union: case ModelValue::Type::Union:
{ {
auto &u = v->template get<ModelUnion>(); auto &u = v->template get<ModelUnion>();
if constexpr(opType_v == OpType::Read) { if constexpr(opType_v == OpType::Read) {
u.setActiveField(m_handler->whichFieldPresent(name, u)); u.setActiveField(m_handler.whichFieldPresent(name, u));
return m_handler->field(name, UnionView<ModelUnion, true>(&u, u.unionIdx())); return m_handler.field(name, UnionView<ModelUnion, true>(&u, u.unionIdx()));
} else { } else {
return m_handler->field(name, UnionView<const ModelUnion, true>(&u, u.unionIdx())); return m_handler.field(name, UnionView<const ModelUnion, true>(&u, u.unionIdx()));
} }
} }
case ModelValue::Type::Vector: case ModelValue::Type::Vector:
return m_handler->field(name, &v->template get<ModelValueVector>()); return m_handler.field(name, &v->template get<ModelValueVector>());
case ModelValue::Type::InlineArray: case ModelValue::Type::InlineArray:
return m_handler->field(name, &v->template get<ModelValueArray>()); return m_handler.field(name, &v->template get<ModelValueArray>());
} }
oxErrf("invalid type: {}: {}\n", name, static_cast<int>(v->type())); oxErrf("invalid type: {}: {}\n", name, static_cast<int>(v->type()));
ox::panic("invalid type"); ox::panic("invalid type");
@@ -142,7 +142,7 @@ class ModelHandlerInterface {
// array handler, with callback to allow handling individual elements // array handler, with callback to allow handling individual elements
template<typename T, typename Callback> template<typename T, typename Callback>
constexpr Error field(const char *name, Callback cb) noexcept { constexpr Error field(const char *name, Callback cb) noexcept {
return m_handler->template field<T, Callback>(name, cb); return m_handler.template field<T, Callback>(name, cb);
} }
template<typename T> template<typename T>
@@ -150,7 +150,7 @@ class ModelHandlerInterface {
if constexpr(ox::is_same_v<T, ModelValue>) { if constexpr(ox::is_same_v<T, ModelValue>) {
return fieldModelValue(name, v); return fieldModelValue(name, v);
} else { } else {
return m_handler->field(name, v); return m_handler.field(name, v);
} }
} }
@@ -159,26 +159,27 @@ class ModelHandlerInterface {
if constexpr(ox::is_same_v<T, ModelValue>) { if constexpr(ox::is_same_v<T, ModelValue>) {
return fieldModelValue(name, v); return fieldModelValue(name, v);
} else { } else {
return m_handler->field(name, v); return m_handler.field(name, v);
} }
} }
template<typename U, bool force = false> template<typename U, bool force = false>
constexpr Error field(const char *name, UnionView<U, force> val) noexcept { constexpr Error field(const char *name, UnionView<U, force> val) noexcept {
return m_handler->field(name, val); return m_handler.field(name, val);
} }
constexpr Error field(const char *name, auto *val, std::size_t len) noexcept { constexpr Error field(const char *name, auto *val, std::size_t len) noexcept {
return m_handler->field(name, val, len); return m_handler.field(name, val, len);
} }
/** /**
* Reads an array length from the current location in the buffer. * Reads an array length from the current location in the buffer.
* @param name
* @param pass indicates that the parsing should iterate past the array length * @param pass indicates that the parsing should iterate past the array length
*/ */
[[nodiscard]] [[nodiscard]]
constexpr auto arrayLength(const char *name, bool pass = true) noexcept { constexpr auto arrayLength(const char *name, bool pass = true) noexcept {
return m_handler->arrayLength(name, pass); return m_handler.arrayLength(name, pass);
} }
/** /**
@@ -186,7 +187,7 @@ class ModelHandlerInterface {
*/ */
[[nodiscard]] [[nodiscard]]
constexpr auto stringLength(const char *name) noexcept { constexpr auto stringLength(const char *name) noexcept {
return m_handler->stringLength(name); return m_handler.stringLength(name);
} }
[[nodiscard]] [[nodiscard]]
@@ -200,20 +201,17 @@ class ModelHandlerInterface {
} }
}; };
template<typename Handler, ox::OpType opType_v = Handler::opType()> template<typename Handler, OpType opType_v = Handler::opType()>
class ModelHandlerBase { class ModelHandlerBase {
private: private:
ModelHandlerInterface<Handler, opType_v> m_interface; ModelHandlerInterface<Handler, opType_v> m_interface{*static_cast<Handler*>(this)};
public: public:
constexpr ModelHandlerBase() noexcept: m_interface(static_cast<Handler*>(this)) {}
constexpr ModelHandlerBase(const ModelHandlerBase&) noexcept: m_interface(static_cast<Handler*>(this)) {}
constexpr ModelHandlerBase(ModelHandlerBase&&) noexcept: m_interface(static_cast<Handler*>(this)) {}
[[nodiscard]] [[nodiscard]]
constexpr auto interface() noexcept { constexpr auto interface() noexcept {
return &m_interface; return &m_interface;
} }
[[nodiscard]] [[nodiscard]]
static constexpr ox::OpType opType() noexcept { static constexpr OpType opType() noexcept {
return opType_v; return opType_v;
} }
}; };

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

@@ -13,31 +13,31 @@
namespace ox { namespace ox {
OrganicClawReader::OrganicClawReader(const uint8_t *buff, std::size_t buffSize) { OrganicClawReader::OrganicClawReader(const uint8_t *buff, size_t const buffSize) {
auto json = reinterpret_cast<const char*>(buff); auto json = reinterpret_cast<const char*>(buff);
auto jsonLen = ox::strnlen_s(json, buffSize); auto jsonLen = ox::strnlen_s(json, buffSize);
Json::CharReaderBuilder parserBuilder; Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader()); auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader());
if (!parser->parse(json, json + jsonLen, &m_json, nullptr)) { if (!parser->parse(json, json + jsonLen, &m_json, nullptr)) {
throw ox::Exception(1, "Could not parse JSON"); throw Exception(1, "Could not parse JSON");
} }
} }
OrganicClawReader::OrganicClawReader(const char *json, std::size_t jsonLen) { OrganicClawReader::OrganicClawReader(CString const json, size_t const jsonLen) {
Json::CharReaderBuilder parserBuilder; Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader()); auto parser = std::unique_ptr<Json::CharReader>(parserBuilder.newCharReader());
if (!parser->parse(json, json + jsonLen, &m_json, nullptr)) { if (!parser->parse(json, json + jsonLen, &m_json, nullptr)) {
throw ox::Exception(1, "Could not parse JSON"); throw Exception(1, "Could not parse JSON");
} }
} }
OrganicClawReader::OrganicClawReader(Json::Value json, int unionIdx) noexcept: OrganicClawReader::OrganicClawReader(Json::Value json, int const unionIdx) noexcept:
m_json(std::move(json)), m_json(std::move(json)),
m_unionIdx(unionIdx) { m_unionIdx(unionIdx) {
} }
Error OrganicClawReader::field(const char *key, bool *val) noexcept { Error OrganicClawReader::field(CString const key, bool *val) noexcept {
ox::Error err{}; Error err{};
if (targetValid()) { if (targetValid()) {
const auto &jv = value(key); const auto &jv = value(key);
if (jv.empty()) { if (jv.empty()) {
@@ -45,16 +45,16 @@ Error OrganicClawReader::field(const char *key, bool *val) noexcept {
} else if (jv.isBool()) { } else if (jv.isBool()) {
*val = jv.asBool(); *val = jv.asBool();
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error(1, "Type mismatch");
} }
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
Error OrganicClawReader::fieldCString(const char *key, char *val, std::size_t buffLen) noexcept { Error OrganicClawReader::fieldCString(CString const key, char *val, size_t const buffLen) noexcept {
ox::Error err{}; Error err{};
const char *begin = nullptr, *end = nullptr; CString begin = nullptr, end = nullptr;
const auto &jv = value(key); const auto &jv = value(key);
if (targetValid()) { if (targetValid()) {
if (jv.empty()) { if (jv.empty()) {
@@ -64,25 +64,25 @@ Error OrganicClawReader::fieldCString(const char *key, char *val, std::size_t bu
} }
} else if (jv.isString()) { } else if (jv.isString()) {
jv.getString(&begin, &end); jv.getString(&begin, &end);
const auto strSize = static_cast<std::size_t>(end - begin); const auto strSize = static_cast<size_t>(end - begin);
auto data = val; auto data = val;
if (strSize >= buffLen) { if (strSize >= buffLen) {
err = ox::Error(2, "String size exceeds capacity of destination"); err = Error(2, "String size exceeds capacity of destination");
} else { } else {
ox::memcpy(data, begin, static_cast<std::size_t>(strSize)); memcpy(data, begin, static_cast<size_t>(strSize));
data[strSize] = 0; data[strSize] = 0;
} }
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error(1, "Type mismatch");
} }
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
Error OrganicClawReader::fieldCString(const char *key, char **val) noexcept { Error OrganicClawReader::fieldCString(CString const key, char **val) noexcept {
ox::Error err{}; Error err{};
const char *begin = nullptr, *end = nullptr; CString begin = nullptr, end = nullptr;
const auto &jv = value(key); const auto &jv = value(key);
auto &data = *val; auto &data = *val;
if (targetValid()) { if (targetValid()) {
@@ -92,22 +92,22 @@ Error OrganicClawReader::fieldCString(const char *key, char **val) noexcept {
} }
} else if (jv.isString()) { } else if (jv.isString()) {
jv.getString(&begin, &end); jv.getString(&begin, &end);
const auto strSize = static_cast<std::size_t>(end - begin); const auto strSize = static_cast<size_t>(end - begin);
safeDelete(*val); safeDelete(*val);
*val = new char[strSize + 1]; *val = new char[strSize + 1];
ox::memcpy(data, begin, static_cast<std::size_t>(strSize)); memcpy(data, begin, static_cast<size_t>(strSize));
data[strSize] = 0; data[strSize] = 0;
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error(1, "Type mismatch");
} }
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
Error OrganicClawReader::fieldCString(const char *key, char **val, std::size_t buffLen) noexcept { Error OrganicClawReader::fieldCString(CString const key, char **val, size_t const buffLen) noexcept {
ox::Error err{}; Error err{};
const char *begin = nullptr, *end = nullptr; CString begin = nullptr, end = nullptr;
const auto &jv = value(key); const auto &jv = value(key);
if (targetValid()) { if (targetValid()) {
if (jv.empty()) { if (jv.empty()) {
@@ -117,29 +117,29 @@ Error OrganicClawReader::fieldCString(const char *key, char **val, std::size_t b
} }
} else if (jv.isString()) { } else if (jv.isString()) {
jv.getString(&begin, &end); jv.getString(&begin, &end);
const auto strSize = static_cast<std::size_t>(end - begin); const auto strSize = static_cast<size_t>(end - begin);
auto data = val; auto data = val;
if (strSize >= buffLen) { if (strSize >= buffLen) {
safeDelete(*val); safeDelete(*val);
*val = new char[strSize + 1]; *val = new char[strSize + 1];
} }
ox::memcpy(data, begin, static_cast<std::size_t>(strSize)); memcpy(data, begin, static_cast<size_t>(strSize));
data[strSize] = nullptr; data[strSize] = nullptr;
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error(1, "Type mismatch");
} }
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
Error OrganicClawReader::field(const char *key, UUID *val) noexcept { Error OrganicClawReader::field(CString const key, UUID *val) noexcept {
UUIDStr str; UUIDStr str;
OX_RETURN_ERROR(field(key, &str)); OX_RETURN_ERROR(field(key, &str));
return UUID::fromString(str).moveTo(*val); return UUID::fromString(str).moveTo(*val);
} }
Result<std::size_t> OrganicClawReader::arrayLength(const char *key, bool) noexcept { Result<size_t> OrganicClawReader::arrayLength(CString const key, bool) noexcept {
const auto &jv = value(key); const auto &jv = value(key);
if (jv.empty()) { if (jv.empty()) {
return 0; return 0;
@@ -147,32 +147,32 @@ Result<std::size_t> OrganicClawReader::arrayLength(const char *key, bool) noexce
if (jv.isArray()) { if (jv.isArray()) {
return jv.size(); return jv.size();
} }
return ox::Error(1, "Type mismatch"); return Error(1, "Type mismatch");
} }
[[nodiscard]] [[nodiscard]]
std::size_t OrganicClawReader::stringLength(const char *key) noexcept { size_t OrganicClawReader::stringLength(CString const key) noexcept {
const char *begin = nullptr, *end = nullptr; CString begin = nullptr, end = nullptr;
const auto &jv = value(key); const auto &jv = value(key);
if (jv.empty()) { if (jv.empty()) {
return 0; return 0;
} }
if (jv.isString()) { if (jv.isString()) {
jv.getString(&begin, &end); jv.getString(&begin, &end);
return static_cast<std::size_t>(end - begin); return static_cast<size_t>(end - begin);
} }
return ox::Error(1, "Type mismatch"); return Error(1, "Type mismatch");
} }
OrganicClawReader OrganicClawReader::child(const char *key, int unionIdx) noexcept { OrganicClawReader OrganicClawReader::child(CString const key, int const unionIdx) noexcept {
return OrganicClawReader(value(key), unionIdx); return OrganicClawReader(value(key), unionIdx);
} }
bool OrganicClawReader::fieldPresent(const char *key) noexcept { bool OrganicClawReader::fieldPresent(CString const key) noexcept {
return !m_json[key].empty(); return !m_json[key].empty();
} }
int OrganicClawReader::whichFieldPresent(const char *name, const ModelUnion &u) const noexcept { int OrganicClawReader::whichFieldPresent(CString const name, ModelUnion const &u) const noexcept {
const auto &obj = m_json[name]; const auto &obj = m_json[name];
if (!obj.isObject()) { if (!obj.isObject()) {
return -1; return -1;
@@ -184,7 +184,7 @@ int OrganicClawReader::whichFieldPresent(const char *name, const ModelUnion &u)
return u.getKeyIdx(keys.front().c_str()); return u.getKeyIdx(keys.front().c_str());
} }
Json::Value &OrganicClawReader::value(const char *key) noexcept { Json::Value &OrganicClawReader::value(CString const key) noexcept {
if (m_json.isArray()) { if (m_json.isArray()) {
return m_json[m_fieldIt]; return m_json[m_fieldIt];
} else { } else {

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

@@ -34,75 +34,76 @@ class OrganicClawReader {
private: private:
Json::Value m_json; Json::Value m_json;
Json::ArrayIndex m_fieldIt = 0; Json::ArrayIndex m_fieldIt = 0;
int m_unionIdx = -1; int const m_unionIdx = -1;
public: public:
OrganicClawReader() noexcept = default; OrganicClawReader() noexcept = default;
OrganicClawReader(const uint8_t *buff, std::size_t buffSize); OrganicClawReader(uint8_t const *buff, size_t buffSize);
OrganicClawReader(const char *json, std::size_t buffSize); OrganicClawReader(CString json, size_t buffSize);
explicit OrganicClawReader(Json::Value json, int unionIdx = -1) noexcept; explicit OrganicClawReader(Json::Value json, int unionIdx = -1) noexcept;
Error field(const char *key, bool *val) noexcept; Error field(CString key, bool *val) noexcept;
// array handler // array handler
template<typename T> template<typename T>
Error field(const char *key, T *val, std::size_t len) noexcept; Error field(CString key, T *val, size_t len) noexcept;
template<typename T> template<typename T>
Error field(const char*, HashMap<String, T> *val) noexcept; Error field(CString, HashMap<String, T> *val) noexcept;
template<typename T> template<typename T>
Error field(const char *key, T *val) noexcept; Error field(CString key, T *val) noexcept;
template<typename U, bool force = false> template<typename U, bool force = false>
Error field(const char *key, UnionView<U, force> val) noexcept; Error field(CString key, UnionView<U, force> val) noexcept;
template<std::size_t L> template<size_t L>
Error field(const char *key, BasicString<L> *val) noexcept; Error field(CString key, BasicString<L> *val) noexcept;
template<std::size_t L> template<size_t L>
Error field(const char *key, IString<L> *val) noexcept; Error field(CString key, IString<L> *val) noexcept;
Error fieldCString(const char *key, char *val, std::size_t buffLen) noexcept; Error fieldCString(CString key, char *val, size_t buffLen) noexcept;
Error fieldCString(const char *key, char **val) noexcept; Error fieldCString(CString key, char **val) noexcept;
Error fieldCString(const char *key, char **val, std::size_t buffLen) noexcept; Error fieldCString(CString key, char **val, size_t buffLen) noexcept;
Error field(const char *key, UUID *val) noexcept; Error field(CString key, UUID *val) noexcept;
/** /**
* Reads an array length from the current location in the buffer. * Reads an array length from the current location in the buffer.
* @param key
* @param pass indicates that the parsing should iterate past the array length * @param pass indicates that the parsing should iterate past the array length
*/ */
Result<std::size_t> arrayLength(const char *key, bool pass = true) noexcept; Result<size_t> arrayLength(CString key, bool pass = true) noexcept;
/** /**
* Reads an string length from the current location in the buffer. * Reads an string length from the current location in the buffer.
*/ */
[[nodiscard]] [[nodiscard]]
std::size_t stringLength(const char *name) noexcept; size_t stringLength(CString key) noexcept;
template<typename T = void> template<typename T = void>
constexpr ox::Error setTypeInfo() noexcept { constexpr Error setTypeInfo() noexcept {
return {}; return {};
} }
template<typename T = void> template<typename T = void>
constexpr ox::Error setTypeInfo(const char*) noexcept { constexpr Error setTypeInfo(CString) noexcept {
return {}; return {};
} }
template<typename T = void> template<typename T = void>
constexpr ox::Error setTypeInfo(const char*, int, const Vector<String>& = {}) noexcept { constexpr Error setTypeInfo(CString, int, const Vector<String>& = {}) noexcept {
return {}; return {};
} }
template<typename T = void> template<typename T = void>
constexpr ox::Error setTypeInfo(const char*, int, const Vector<String>& = {}, std::size_t = {}) noexcept { constexpr Error setTypeInfo(CString, int, const Vector<String>& = {}, size_t = {}) noexcept {
return {}; return {};
} }
@@ -110,16 +111,16 @@ class OrganicClawReader {
* Returns a OrganicClawReader to parse a child object. * Returns a OrganicClawReader to parse a child object.
*/ */
[[nodiscard]] [[nodiscard]]
OrganicClawReader child(const char *key, int unionIdx = -1) noexcept; OrganicClawReader child(CString key, int unionIdx = -1) noexcept;
// compatibility stub // compatibility stub
constexpr void nextField() noexcept {} constexpr void nextField() noexcept {}
[[nodiscard]] [[nodiscard]]
bool fieldPresent(const char *key) noexcept; bool fieldPresent(CString key) noexcept;
[[nodiscard]] [[nodiscard]]
int whichFieldPresent(const char *name, const ModelUnion &u) const noexcept; int whichFieldPresent(CString name, const ModelUnion &u) const noexcept;
[[nodiscard]] [[nodiscard]]
static constexpr auto opType() noexcept { static constexpr auto opType() noexcept {
@@ -128,7 +129,7 @@ class OrganicClawReader {
private: private:
[[nodiscard]] [[nodiscard]]
Json::Value &value(const char *key) noexcept; Json::Value &value(CString key) noexcept;
[[nodiscard]] [[nodiscard]]
bool targetValid() const noexcept; bool targetValid() const noexcept;
@@ -136,102 +137,102 @@ class OrganicClawReader {
}; };
template<typename T> template<typename T>
Error OrganicClawReader::field(const char *key, T *val) noexcept { Error OrganicClawReader::field(CString key, T *val) noexcept {
ox::Error err{}; Error err{};
try { try {
if constexpr (is_integer_v<T>) { if constexpr (is_integer_v<T>) {
if (targetValid()) { if (targetValid()) {
auto const&jv = value(key); auto const &jv = value(key);
auto const rightType = sizeof(T) == 8 ? auto const rightType = sizeof(T) == 8 ?
(ox::is_signed_v<T> ? jv.isInt64() : jv.isUInt64()) : (is_signed_v<T> ? jv.isInt64() : jv.isUInt64()) :
(ox::is_signed_v<T> ? jv.isInt() : jv.isUInt()); (is_signed_v<T> ? jv.isInt() : jv.isUInt());
if (jv.empty()) { if (jv.empty()) {
*val = 0; *val = 0;
} else if (rightType) { } else if (rightType) {
if constexpr(ox::is_signed_v<T>) { if constexpr(is_signed_v<T>) {
*val = static_cast<T>(jv.asInt64()); *val = static_cast<T>(jv.asInt64());
} else { } else {
*val = static_cast<T>(jv.asUInt64()); *val = static_cast<T>(jv.asUInt64());
} }
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error{1, "Type mismatch"};
} }
} }
} else if constexpr (isVector_v<T>) { } else if constexpr (isVector_v<T>) {
const auto&srcVal = value(key); auto const &srcVal = value(key);
const auto srcSize = srcVal.size(); auto const srcSize = srcVal.size();
OX_RETURN_ERROR(ox::resizeVector(*val, srcSize)); OX_RETURN_ERROR(resizeVector(*val, srcSize));
err = field(key, val->data(), val->size()); err = field(key, val->data(), val->size());
} else if constexpr (isArray_v<T>) { } else if constexpr (isArray_v<T>) {
const auto&srcVal = value(key); auto const &srcVal = value(key);
const auto srcSize = srcVal.size(); auto const srcSize = srcVal.size();
if (srcSize > val->size()) { if (srcSize > val->size()) {
err = ox::Error(1, "Input array is too long"); err = Error{1, "Input array is too long"};
} else { } else {
err = field(key, val->data(), val->size()); err = field(key, val->data(), val->size());
} }
} else if (targetValid()) { } else if (targetValid()) {
const auto&jv = value(key); auto const &jv = value(key);
if (jv.empty() || jv.isObject()) { if (jv.empty() || jv.isObject()) {
auto reader = child(key); auto reader = child(key);
ModelHandlerInterface handler(&reader); ModelHandlerInterface handler(reader);
err = model(&handler, val); err = model(&handler, val);
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error{1, "Type mismatch"};
} }
} }
} catch (Json::LogicError const&e) { } catch (Json::LogicError const &e) {
err = ox::Error(1, "error reading JSON data"); err = Error{1, "error reading JSON data"};
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
template<typename U, bool force> template<typename U, bool force>
Error OrganicClawReader::field(const char *key, UnionView<U, force> val) noexcept { Error OrganicClawReader::field(CString const key, UnionView<U, force> val) noexcept {
ox::Error err{}; Error err{};
if (targetValid()) { if (targetValid()) {
const auto &jv = value(key); auto const &jv = value(key);
if (jv.empty() || jv.isObject()) { if (jv.empty() || jv.isObject()) {
auto reader = child(key, val.idx()); auto reader = child(key, val.idx());
ModelHandlerInterface handler(&reader); ModelHandlerInterface handler(reader);
err = model(&handler, val.get()); err = model(&handler, val.get());
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error{1, "Type mismatch"};
} }
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
template<std::size_t L> template<size_t L>
Error OrganicClawReader::field(const char *key, BasicString<L> *val) noexcept { Error OrganicClawReader::field(CString const key, BasicString<L> *val) noexcept {
ox::Error err{}; Error err{};
if (targetValid()) { if (targetValid()) {
const auto &jv = value(key); auto const &jv = value(key);
if (jv.empty()) { if (jv.empty()) {
*val = BasicString<L>{}; *val = BasicString<L>{};
} else if (jv.isString()) { } else if (jv.isString()) {
*val = jv.asString().c_str(); *val = jv.asString().c_str();
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error{1, "Type mismatch"};
} }
} }
++m_fieldIt; ++m_fieldIt;
return err; return err;
} }
template<std::size_t L> template<size_t L>
Error OrganicClawReader::field(const char *key, IString<L> *val) noexcept { Error OrganicClawReader::field(CString const key, IString<L> *val) noexcept {
ox::Error err{}; Error err{};
if (targetValid()) { if (targetValid()) {
const auto &jv = value(key); auto const &jv = value(key);
if (jv.empty()) { if (jv.empty()) {
*val = IString<L>{}; *val = IString<L>{};
} else if (jv.isString()) { } else if (jv.isString()) {
*val = jv.asString().c_str(); *val = jv.asString().c_str();
} else { } else {
err = ox::Error(1, "Type mismatch"); err = Error{1, "Type mismatch"};
} }
} }
++m_fieldIt; ++m_fieldIt;
@@ -240,17 +241,17 @@ Error OrganicClawReader::field(const char *key, IString<L> *val) noexcept {
// array handler // array handler
template<typename T> template<typename T>
Error OrganicClawReader::field(const char *key, T *val, std::size_t valLen) noexcept { Error OrganicClawReader::field(CString const key, T *val, size_t valLen) noexcept {
const auto &srcVal = value(key); auto const &srcVal = value(key);
if (!srcVal.isNull() && !srcVal.isArray()) { if (!srcVal.isNull() && !srcVal.isArray()) {
return ox::Error(1, "Type mismatch"); return Error{1, "Type mismatch"};
} }
auto srcSize = srcVal.size(); auto srcSize = srcVal.size();
if (srcSize > valLen) { if (srcSize > valLen) {
return ox::Error(1); return Error{1};
} }
OrganicClawReader r(srcVal); OrganicClawReader r(srcVal);
ModelHandlerInterface handler{&r}; ModelHandlerInterface handler{r};
for (decltype(srcSize) i = 0; i < srcSize; ++i) { for (decltype(srcSize) i = 0; i < srcSize; ++i) {
OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_ALLOW_UNSAFE_BUFFERS_BEGIN
OX_RETURN_ERROR(handler.field("", &val[i])); OX_RETURN_ERROR(handler.field("", &val[i]));
@@ -260,23 +261,23 @@ OX_ALLOW_UNSAFE_BUFFERS_END
} }
template<typename T> template<typename T>
Error OrganicClawReader::field(const char *key, HashMap<String, T> *val) noexcept { Error OrganicClawReader::field(CString const key, HashMap<String, T> *val) noexcept {
const auto &srcVal = value(key); auto const &srcVal = value(key);
if (!srcVal.isObject()) { if (!srcVal.isObject()) {
return ox::Error(1, "Type mismatch"); return Error{1, "Type mismatch"};
} }
auto keys = srcVal.getMemberNames(); auto keys = srcVal.getMemberNames();
auto srcSize = srcVal.size(); auto srcSize = srcVal.size();
OrganicClawReader r(srcVal); OrganicClawReader r(srcVal);
ModelHandlerInterface handler{&r}; ModelHandlerInterface handler{r};
for (decltype(srcSize) i = 0; i < srcSize; ++i) { for (decltype(srcSize) i = 0; i < srcSize; ++i) {
const auto k = keys[i].c_str(); auto const k = keys[i].c_str();
OX_RETURN_ERROR(handler.field(k, &val->operator[](k))); OX_RETURN_ERROR(handler.field(k, &val->operator[](k)));
} }
return {}; return {};
} }
Error readOC(BufferView buff, auto &val) noexcept { Error readOC(BufferView const buff, auto &val) noexcept {
// OrganicClawReader constructor can throw, but readOC should return its errors. // OrganicClawReader constructor can throw, but readOC should return its errors.
try { try {
Json::Value doc; Json::Value doc;
@@ -285,15 +286,15 @@ Error readOC(BufferView buff, auto &val) noexcept {
OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_ALLOW_UNSAFE_BUFFERS_BEGIN
if (!parser->parse(buff.data(), buff.data() + buff.size(), &doc, nullptr)) { if (!parser->parse(buff.data(), buff.data() + buff.size(), &doc, nullptr)) {
OX_ALLOW_UNSAFE_BUFFERS_END OX_ALLOW_UNSAFE_BUFFERS_END
return ox::Error(1, "Could not parse JSON"); return Error{1, "Could not parse JSON"};
} }
OrganicClawReader reader(buff.data(), buff.size()); OrganicClawReader reader(buff.data(), buff.size());
ModelHandlerInterface handler(&reader); ModelHandlerInterface handler(reader);
return model(&handler, &val); return model(&handler, &val);
} catch (const Error &err) { } catch (Error const &err) {
return err; return err;
} catch (...) { } catch (...) {
return ox::Error(1, "Unknown Error"); return Error{1, "Unknown Error"};
} }
} }
@@ -305,8 +306,8 @@ Result<T> readOC(BufferView buff) noexcept {
} }
template<typename T> template<typename T>
Result<T> readOC(ox::StringView json) noexcept { Result<T> readOC(StringViewCR json) noexcept {
return readOC<T>(ox::BufferView{json.data(), json.size()}); return readOC<T>(BufferView{json.data(), json.size()});
} }
} }

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

@@ -10,15 +10,15 @@
namespace ox { namespace ox {
OrganicClawWriter::OrganicClawWriter(int unionIdx) noexcept: m_unionIdx(unionIdx) { OrganicClawWriter::OrganicClawWriter(int const unionIdx) noexcept: m_unionIdx(unionIdx) {
} }
OrganicClawWriter::OrganicClawWriter(Json::Value json, int unionIdx) noexcept: OrganicClawWriter::OrganicClawWriter(Json::Value json, int const unionIdx) noexcept:
m_json(std::move(json)), m_json(std::move(json)),
m_unionIdx(unionIdx) { m_unionIdx(unionIdx) {
} }
Error OrganicClawWriter::fieldCString(const char *key, const char *const*val, int len) noexcept { Error OrganicClawWriter::fieldCString(const char *key, const char *const *val, int const len) noexcept {
if (targetValid() && len) { if (targetValid() && len) {
value(key) = *val; value(key) = *val;
} }
@@ -26,11 +26,11 @@ Error OrganicClawWriter::fieldCString(const char *key, const char *const*val, in
return {}; return {};
} }
Error OrganicClawWriter::fieldCString(const char *key, const char *const*val) noexcept { Error OrganicClawWriter::fieldCString(const char *key, const char *const *val) noexcept {
return fieldCString(key, const_cast<const char**>(val), static_cast<int>(ox::strlen(val))); return fieldCString(key, const_cast<const char**>(val), static_cast<int>(ox::strlen(val)));
} }
Error OrganicClawWriter::field(const char *key, const UUID *uuid) noexcept { Error OrganicClawWriter::field(const char *key, UUID const *uuid) noexcept {
const auto uuidStr = uuid->toString(); const auto uuidStr = uuid->toString();
if (targetValid() && uuidStr.size()) { if (targetValid() && uuidStr.size()) {
value(key) = uuidStr.c_str(); value(key) = uuidStr.c_str();

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

@@ -28,20 +28,20 @@ namespace ox {
class OrganicClawWriter { class OrganicClawWriter {
friend Result<ox::Buffer> writeOC(const auto &val) noexcept; friend Result<Buffer> writeOC(const auto &val) noexcept;
friend Result<ox::String> writeOCString(const auto &val) noexcept; friend Result<String> writeOCString(const auto &val) noexcept;
protected: protected:
Json::Value m_json{Json::Value(Json::objectValue)}; Json::Value m_json{Json::Value(Json::objectValue)};
Json::ArrayIndex m_fieldIt = 0; Json::ArrayIndex m_fieldIt = 0;
int m_unionIdx = -1; int const m_unionIdx = -1;
public: public:
explicit OrganicClawWriter(int unionIdx = -1) noexcept; explicit OrganicClawWriter(int unionIdx = -1) noexcept;
explicit OrganicClawWriter(Json::Value json, int unionIdx = -1) noexcept; explicit OrganicClawWriter(Json::Value json, int unionIdx = -1) noexcept;
Error field(const char *key, const int8_t *val) noexcept { Error field(const char *key, int8_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -49,7 +49,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(const char *key, const int16_t *val) noexcept { Error field(const char *key, int16_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -57,7 +57,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(const char *key, const int32_t *val) noexcept { Error field(const char *key, int32_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -65,7 +65,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(const char *key, const int64_t *val) noexcept { Error field(const char *key, int64_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -74,7 +74,7 @@ class OrganicClawWriter {
} }
Error field(const char *key, const uint8_t *val) noexcept { Error field(const char *key, uint8_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -82,7 +82,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(const char *key, const uint16_t *val) noexcept { Error field(const char *key, uint16_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -90,7 +90,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(const char *key, const uint32_t *val) noexcept { Error field(const char *key, uint32_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -98,7 +98,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(const char *key, const uint64_t *val) noexcept { Error field(const char *key, uint64_t const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -106,7 +106,7 @@ class OrganicClawWriter {
return {}; return {};
} }
Error field(char const*key, bool const*val) noexcept { Error field(char const*key, bool const *val) noexcept {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
value(key) = *val; value(key) = *val;
} }
@@ -118,12 +118,12 @@ class OrganicClawWriter {
Error field(char const*, UnionView<U, force> val) noexcept; Error field(char const*, UnionView<U, force> val) noexcept;
template<typename T> template<typename T>
Error field(char const*key, HashMap<String, T> const*val) noexcept { Error field(char const*key, HashMap<String, T> const *val) noexcept {
if (targetValid()) { if (targetValid()) {
const auto &keys = val->keys(); const auto &keys = val->keys();
OrganicClawWriter w; OrganicClawWriter w;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w}; ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{w};
for (std::size_t i = 0; i < keys.size(); ++i) { for (size_t i = 0; i < keys.size(); ++i) {
const auto k = keys[i].c_str(); const auto k = keys[i].c_str();
if (k) [[likely]] { if (k) [[likely]] {
OX_REQUIRE_M(value, val->at(k)); OX_REQUIRE_M(value, val->at(k));
@@ -136,8 +136,8 @@ class OrganicClawWriter {
return {}; return {};
} }
template<std::size_t L> template<size_t L>
Error field(char const*key, IString<L> const*val) noexcept { Error field(char const*key, IString<L> const *val) noexcept {
if (targetValid() && val->size()) { if (targetValid() && val->size()) {
value(key) = val->c_str(); value(key) = val->c_str();
} }
@@ -145,8 +145,8 @@ class OrganicClawWriter {
return {}; return {};
} }
template<std::size_t L> template<size_t L>
Error field(char const*key, BasicString<L> const*val) noexcept { Error field(char const*key, BasicString<L> const *val) noexcept {
if (targetValid() && val->size()) { if (targetValid() && val->size()) {
value(key) = val->c_str(); value(key) = val->c_str();
} }
@@ -154,31 +154,31 @@ class OrganicClawWriter {
return {}; return {};
} }
Error fieldCString(const char*, const char *const*val, int len) noexcept; Error fieldCString(const char*, const char *const *val, int len) noexcept;
Error fieldCString(const char *name, const char *const*val) noexcept; Error fieldCString(const char *name, const char *const*val) noexcept;
Error field(const char *key, const UUID *uuid) noexcept; Error field(const char *key, UUID const *uuid) noexcept;
template<typename T> template<typename T>
Error field(const char*, const T *val, std::size_t len) noexcept; Error field(const char*, T const *val, size_t len) noexcept;
template<typename T> template<typename T>
Error field(const char*, const T *val) noexcept; Error field(const char*, T const *val) noexcept;
template<typename T> template<typename T>
constexpr ox::Error setTypeInfo( constexpr Error setTypeInfo(
const char* = T::TypeName, const char* = T::TypeName,
int = T::TypeVersion) noexcept { int = T::TypeVersion) noexcept {
return {}; return {};
} }
template<typename T> template<typename T>
constexpr ox::Error setTypeInfo( constexpr Error setTypeInfo(
const char*, const char*,
int, int,
const Vector<String>&, Vector<String> const&,
std::size_t) noexcept { size_t) noexcept {
return {}; return {};
} }
@@ -199,11 +199,11 @@ class OrganicClawWriter {
}; };
template<typename T> template<typename T>
Error OrganicClawWriter::field(const char *key, const T *val, std::size_t len) noexcept { Error OrganicClawWriter::field(const char *key, T const *val, size_t const len) noexcept {
if (targetValid() && len) { if (targetValid() && len) {
OrganicClawWriter w((Json::Value(Json::arrayValue))); OrganicClawWriter w((Json::Value(Json::arrayValue)));
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w}; ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{w};
for (std::size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_ALLOW_UNSAFE_BUFFERS_BEGIN
OX_RETURN_ERROR(handler.field({}, &val[i])); OX_RETURN_ERROR(handler.field({}, &val[i]));
OX_ALLOW_UNSAFE_BUFFERS_END OX_ALLOW_UNSAFE_BUFFERS_END
@@ -215,22 +215,22 @@ OX_ALLOW_UNSAFE_BUFFERS_END
} }
template<typename T> template<typename T>
Error OrganicClawWriter::field(const char *key, const T *val) noexcept { Error OrganicClawWriter::field(const char *key, T const *val) noexcept {
if constexpr(is_integer_v<T>) { if constexpr(is_integer_v<T>) {
if (targetValid() && (*val || m_json.isArray())) { if (targetValid() && (*val || m_json.isArray())) {
// the int type needs to be normalized because jsoncpp doesn't // the int type needs to be normalized because jsoncpp doesn't
// factor in every permutation unsigned long, etc. // factor in every permutation unsigned long, etc.
if constexpr(ox::is_signed_v<T>) { if constexpr(is_signed_v<T>) {
value(key) = static_cast<ox::Int<8 * sizeof(*val)>>(*val); value(key) = static_cast<Int<8 * sizeof(*val)>>(*val);
} else { } else {
value(key) = static_cast<ox::Uint<8 * sizeof(*val)>>(*val); value(key) = static_cast<Uint<8 * sizeof(*val)>>(*val);
} }
} }
} else if constexpr(isVector_v<T> || isArray_v<T>) { } else if constexpr(isVector_v<T> || isArray_v<T>) {
return field(key, val->data(), val->size()); return field(key, val->data(), val->size());
} else if (val && targetValid()) { } else if (val && targetValid()) {
OrganicClawWriter w; OrganicClawWriter w;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w}; ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{w};
OX_RETURN_ERROR(model(&handler, val)); OX_RETURN_ERROR(model(&handler, val));
if (!w.m_json.empty() || m_json.isArray()) { if (!w.m_json.empty() || m_json.isArray()) {
value(key) = w.m_json; value(key) = w.m_json;
@@ -244,7 +244,7 @@ template<typename U, bool force>
Error OrganicClawWriter::field(const char *key, UnionView<U, force> val) noexcept { Error OrganicClawWriter::field(const char *key, UnionView<U, force> val) noexcept {
if (targetValid()) { if (targetValid()) {
OrganicClawWriter w(val.idx()); OrganicClawWriter w(val.idx());
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w}; ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{w};
OX_RETURN_ERROR(model(&handler, val.get())); OX_RETURN_ERROR(model(&handler, val.get()));
if (!w.m_json.isNull()) { if (!w.m_json.isNull()) {
value(key) = w.m_json; value(key) = w.m_json;
@@ -254,12 +254,12 @@ Error OrganicClawWriter::field(const char *key, UnionView<U, force> val) noexcep
return {}; return {};
} }
Result<ox::Buffer> writeOC(const auto &val) noexcept { Result<Buffer> writeOC(auto const &val) noexcept {
OrganicClawWriter writer; OrganicClawWriter writer;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(&writer); ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(writer);
OX_RETURN_ERROR(model(&handler, &val)); OX_RETURN_ERROR(model(&handler, &val));
Json::StreamWriterBuilder const jsonBuilder; Json::StreamWriterBuilder const jsonBuilder;
const auto str = Json::writeString(jsonBuilder, writer.m_json); auto const str = Json::writeString(jsonBuilder, writer.m_json);
Result<Buffer> buff; Result<Buffer> buff;
buff.value.resize(str.size() + 1); buff.value.resize(str.size() + 1);
OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_ALLOW_UNSAFE_BUFFERS_BEGIN
@@ -268,13 +268,13 @@ Result<ox::Buffer> writeOC(const auto &val) noexcept {
return buff; return buff;
} }
Result<ox::String> writeOCString(const auto &val) noexcept { Result<String> writeOCString(auto const &val) noexcept {
OrganicClawWriter writer; OrganicClawWriter writer;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(&writer); ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(writer);
OX_RETURN_ERROR(model(&handler, &val)); OX_RETURN_ERROR(model(&handler, &val));
Json::StreamWriterBuilder const jsonBuilder; Json::StreamWriterBuilder const jsonBuilder;
const auto str = Json::writeString(jsonBuilder, writer.m_json); auto const str = Json::writeString(jsonBuilder, writer.m_json);
Result<ox::String> buff; Result<String> buff;
buff.value.resize(str.size()); buff.value.resize(str.size());
OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_ALLOW_UNSAFE_BUFFERS_BEGIN
memcpy(buff.value.data(), str.data(), str.size() + 1); memcpy(buff.value.data(), str.data(), str.size() + 1);