From 53aea9731dc2bdf891f8c59bbbbb67a8f8801e82 Mon Sep 17 00:00:00 2001 From: Gary Talent Date: Sun, 25 Jan 2026 23:33:00 -0600 Subject: [PATCH] [ox] Cleanup --- deps/ox/src/ox/claw/read.cpp | 5 +- deps/ox/src/ox/claw/read.hpp | 3 +- deps/ox/src/ox/mc/intops.hpp | 8 +- deps/ox/src/ox/mc/read.hpp | 265 ++++++++++--------- deps/ox/src/ox/mc/write.hpp | 10 +- deps/ox/src/ox/model/descwrite.hpp | 4 +- deps/ox/src/ox/model/modelhandleradaptor.hpp | 80 +++--- deps/ox/src/ox/oc/read.cpp | 76 +++--- deps/ox/src/ox/oc/read.hpp | 153 +++++------ deps/ox/src/ox/oc/write.cpp | 10 +- deps/ox/src/ox/oc/write.hpp | 86 +++--- 11 files changed, 349 insertions(+), 351 deletions(-) diff --git a/deps/ox/src/ox/claw/read.cpp b/deps/ox/src/ox/claw/read.cpp index 4d2e7f1e..c5284bed 100644 --- a/deps/ox/src/ox/claw/read.cpp +++ b/deps/ox/src/ox/claw/read.cpp @@ -106,15 +106,14 @@ Result readClaw(TypeStore &ts, BufferView buff) noexcept { { ox::BufferReader br({header.data, header.dataSize}); MetalClawReader reader(br); - ModelHandlerInterface handler(&reader); - OX_RETURN_ERROR(model(&handler, &obj)); + OX_RETURN_ERROR(model(reader.interface(), &obj)); return obj; } case ClawFormat::Organic: { #ifdef OX_USE_STDLIB OrganicClawReader reader({header.data, header.dataSize}); - ModelHandlerInterface handler(&reader); + ModelHandlerInterface handler(reader); OX_RETURN_ERROR(model(&handler, &obj)); return obj; #else diff --git a/deps/ox/src/ox/claw/read.hpp b/deps/ox/src/ox/claw/read.hpp index b6d69d60..e7488143 100644 --- a/deps/ox/src/ox/claw/read.hpp +++ b/deps/ox/src/ox/claw/read.hpp @@ -52,8 +52,7 @@ Error readClaw(ox::BufferView buff, T &val) { { ox::BufferReader br({header.data, header.dataSize}); MetalClawReader reader(br); - ModelHandlerInterface handler(&reader); - return model(&handler, &val); + return model(reader.interface(), &val); } case ClawFormat::Organic: { diff --git a/deps/ox/src/ox/mc/intops.hpp b/deps/ox/src/ox/mc/intops.hpp index 5659311d..d4092bb4 100644 --- a/deps/ox/src/ox/mc/intops.hpp +++ b/deps/ox/src/ox/mc/intops.hpp @@ -139,19 +139,19 @@ static_assert(countBytes(0b0111'1111) == 8); static_assert(countBytes(0b1111'1111) == 9); template -constexpr Result decodeInteger(Reader_c auto&rdr, std::size_t *bytesRead) noexcept { +constexpr Result decodeInteger(Reader_c auto&rdr, std::size_t &bytesRead) noexcept { uint8_t firstByte = 0; OX_RETURN_ERROR(rdr.read(&firstByte, 1)); OX_RETURN_ERROR(rdr.seekg(-1, ox::ios_base::cur)); const auto bytes = countBytes(firstByte); if (bytes == 9) { - *bytesRead = bytes; + bytesRead = bytes; I out = 0; OX_RETURN_ERROR(rdr.seekg(1, ox::ios_base::cur)); OX_RETURN_ERROR(rdr.read(&out, sizeof(I))); return fromLittleEndian(out); } - *bytesRead = bytes; + bytesRead = bytes; uint64_t decoded = 0; OX_RETURN_ERROR(rdr.read(&decoded, bytes)); decoded >>= bytes; @@ -196,7 +196,7 @@ template Result decodeInteger(McInt m) noexcept { std::size_t bytesRead{}; BufferReader br({reinterpret_cast(m.data.data()), 9}); - return decodeInteger(br, &bytesRead); + return decodeInteger(br, bytesRead); } } diff --git a/deps/ox/src/ox/mc/read.hpp b/deps/ox/src/ox/mc/read.hpp index bbdfb6db..c5dd5ae7 100644 --- a/deps/ox/src/ox/mc/read.hpp +++ b/deps/ox/src/ox/mc/read.hpp @@ -32,58 +32,58 @@ class MetalClawReaderTemplate: public ModelHandlerBase m_fieldPresence; - std::size_t m_fields = 0; - std::size_t m_field = 0; - ox::Optional m_unionIdx; + size_t m_fields{}; + size_t m_field{}; + Optional const m_unionIdx{}; Reader &m_reader; public: explicit constexpr MetalClawReaderTemplate( Reader &reader, - ox::Optional const&unionIdx = {}) noexcept; + Optional const &unionIdx = {}) noexcept; constexpr ~MetalClawReaderTemplate() noexcept; - constexpr Error field(const char*, int8_t *val) noexcept; - constexpr Error field(const char*, int16_t *val) noexcept; - constexpr Error field(const char*, int32_t *val) noexcept; - constexpr Error field(const char*, int64_t *val) noexcept; + constexpr Error field(CString, int8_t *val) noexcept; + constexpr Error field(CString, int16_t *val) noexcept; + constexpr Error field(CString, int32_t *val) noexcept; + constexpr Error field(CString, int64_t *val) noexcept; - constexpr Error field(const char*, uint8_t *val) noexcept; - constexpr Error field(const char*, uint16_t *val) noexcept; - constexpr Error field(const char*, uint32_t *val) noexcept; - constexpr Error field(const char*, uint64_t *val) noexcept; + constexpr Error field(CString, uint8_t *val) noexcept; + constexpr Error field(CString, uint16_t *val) noexcept; + constexpr Error field(CString, uint32_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 - constexpr Error field(const char*, auto *val, std::size_t len) noexcept; + constexpr Error field(CString, auto *val, size_t valLen) noexcept; // map handler template - constexpr Error field(const char*, HashMap *val) noexcept; + constexpr Error field(CString, HashMap *val) noexcept; // array handler, with callback to allow handling individual elements template - constexpr Error field(const char*, CB cb) noexcept; + constexpr Error field(CString, CB cb) noexcept; template - constexpr Error field(const char*, T *val) noexcept; + constexpr Error field(CString, T *val) noexcept; template - constexpr Error field(const char*, UnionView val) noexcept; + constexpr Error field(CString, UnionView val) noexcept; - template - constexpr Error field(const char*, BasicString *val) noexcept; + template + constexpr Error field(CString, BasicString *val) noexcept; - template - constexpr Error field(const char*, IString *val) noexcept; + template + constexpr Error field(CString, IString *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. @@ -101,13 +101,13 @@ class MetalClawReaderTemplate: public ModelHandlerBase& = {}, - std::size_t fields = ModelFieldCount_v) noexcept; + size_t fields = ModelFieldCount_v) noexcept; /** * Returns a MetalClawReader to parse a child object. */ [[nodiscard]] - constexpr MetalClawReaderTemplate child(const char *name, ox::Optional unionIdx = {}) noexcept; + constexpr MetalClawReaderTemplate child(const char *name, Optional unionIdx = {}) noexcept; /** * Indicates whether or not the next field to be read is present. @@ -122,20 +122,20 @@ class MetalClawReaderTemplate: public ModelHandlerBase - constexpr Error readInteger(I *val) noexcept; + constexpr Error readInteger(I &val) noexcept; }; template constexpr MetalClawReaderTemplate::MetalClawReaderTemplate( Reader &reader, - ox::Optional const&unionIdx) noexcept: + Optional const &unionIdx) noexcept: m_fieldPresence(reader), m_unionIdx(unionIdx), m_reader(reader) { @@ -149,50 +149,50 @@ constexpr MetalClawReaderTemplate::~MetalClawReaderTemplate() noexcept { } template -constexpr Error MetalClawReaderTemplate::field(const char*, int8_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, int8_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, int16_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, int16_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, int32_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, int32_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, int64_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, int64_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, uint8_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, uint8_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, uint16_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, uint16_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, uint32_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, uint32_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, uint64_t *val) noexcept { - return readInteger(val); +constexpr Error MetalClawReaderTemplate::field(CString, uint64_t *val) noexcept { + return readInteger(*val); } template -constexpr Error MetalClawReaderTemplate::field(const char*, bool *val) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - auto const result = m_fieldPresence.get(static_cast(m_field)); +constexpr Error MetalClawReaderTemplate::field(CString, bool *val) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + auto const result = m_fieldPresence.get(static_cast(m_field)); *val = result.value; OX_RETURN_ERROR(result); } @@ -202,18 +202,19 @@ constexpr Error MetalClawReaderTemplate::field(const char*, bool *val) n // array handler template -constexpr Error MetalClawReaderTemplate::field(const char *name, auto *val, std::size_t valLen) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::field( + const char *name, auto *val, size_t const valLen) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(len, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(len, mc::decodeInteger(m_reader, bytesRead)); // read the list if (valLen >= len) { auto reader = child({}); auto &handler = *reader.interface(); - OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast(len))); - for (std::size_t i = 0; i < len; ++i) { + OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast(len))); + for (size_t i = 0; i < len; ++i) { OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_RETURN_ERROR(handler.field({}, &val[i])); OX_ALLOW_UNSAFE_BUFFERS_END @@ -230,18 +231,18 @@ OX_ALLOW_UNSAFE_BUFFERS_END template template -constexpr Error MetalClawReaderTemplate::field(const char*, HashMap *val) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::field(CString, HashMap *val) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length OX_REQUIRE(g, m_reader.tellg()); - std::size_t bytesRead = 0; - OX_REQUIRE(len, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(len, mc::decodeInteger(m_reader, bytesRead)); OX_RETURN_ERROR(m_reader.seekg(g)); // read the list auto reader = child(""); auto &handler = *reader.interface(); - OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast(len))); + OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast(len))); // this loop body needs to be in a lambda because of the potential alloca call constexpr auto loopBody = [](auto &handler, auto &val) { OX_REQUIRE(keyLen, handler.stringLength(nullptr)); @@ -250,7 +251,7 @@ constexpr Error MetalClawReaderTemplate::field(const char*, HashMap template constexpr Error MetalClawReaderTemplate::field(const char *name, T *val) noexcept { if constexpr(isVector_v) { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { // set size of val if the field is present, don't worry about it if not - if (m_fieldPresence.get(static_cast(m_field))) { + if (m_fieldPresence.get(static_cast(m_field))) { OX_REQUIRE(len, arrayLength(name, false)); OX_RETURN_ERROR(ox::resizeVector(*val, len)); return field(name, val->data(), val->size()); @@ -275,9 +276,9 @@ constexpr Error MetalClawReaderTemplate::field(const char *name, T *val) ++m_field; return {}; } else if constexpr(isArray_v) { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { // set size of val if the field is present, don't worry about it if not - if (m_fieldPresence.get(static_cast(m_field))) { + if (m_fieldPresence.get(static_cast(m_field))) { OX_REQUIRE(len, arrayLength(name, false)); if (len > val->size()) { return ox::Error(1, "Input array is too long"); @@ -288,8 +289,8 @@ constexpr Error MetalClawReaderTemplate::field(const char *name, T *val) ++m_field; return {}; } else { - if ((!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) && val) { - if (m_fieldPresence.get(static_cast(m_field))) { + if ((!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) && val) { + if (m_fieldPresence.get(static_cast(m_field))) { auto reader = child(""); OX_RETURN_ERROR(model(reader.interface(), val)); } @@ -301,9 +302,9 @@ constexpr Error MetalClawReaderTemplate::field(const char *name, T *val) template template -constexpr Error MetalClawReaderTemplate::field(const char*, UnionView val) noexcept { - if ((!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) && val.get()) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::field(CString, UnionView val) noexcept { + if ((!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) && val.get()) { + if (m_fieldPresence.get(static_cast(m_field))) { auto reader = child("", ox::Optional(ox::in_place, val.idx())); OX_RETURN_ERROR(model(reader.interface(), val.get())); } @@ -313,13 +314,13 @@ constexpr Error MetalClawReaderTemplate::field(const char*, UnionView -template -constexpr Error MetalClawReaderTemplate::field(const char*, BasicString *val) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +template +constexpr Error MetalClawReaderTemplate::field(CString, BasicString *val) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(size, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(size, mc::decodeInteger(m_reader, bytesRead)); const auto cap = size; *val = BasicString(cap); auto data = val->data(); @@ -334,13 +335,13 @@ constexpr Error MetalClawReaderTemplate::field(const char*, BasicString< } template -template -constexpr Error MetalClawReaderTemplate::field(const char*, IString *val) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +template +constexpr Error MetalClawReaderTemplate::field(CString, IString *val) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(size, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(size, mc::decodeInteger(m_reader, bytesRead)); *val = IString(); OX_RETURN_ERROR(val->resize(size)); auto const data = val->data(); @@ -355,11 +356,12 @@ constexpr Error MetalClawReaderTemplate::field(const char*, IString * } template -constexpr Error MetalClawReaderTemplate::fieldCString(const char*, char *val, std::size_t buffLen) noexcept { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::fieldCString( + CString, char *val, size_t const buffLen) noexcept { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(size, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(size, mc::decodeInteger(m_reader, bytesRead)); if (size > buffLen) { return ox::Error(McOutputBuffEnded); } @@ -374,11 +376,11 @@ constexpr Error MetalClawReaderTemplate::fieldCString(const char*, char } template -constexpr Error MetalClawReaderTemplate::fieldCString(const char*, char **val) noexcept { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::fieldCString(CString, char **val) noexcept { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(size, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(size, mc::decodeInteger(m_reader, bytesRead)); // re-allocate in case too small safeDelete(*val); *val = new char[size + 1]; @@ -392,12 +394,12 @@ constexpr Error MetalClawReaderTemplate::fieldCString(const char*, char } template -constexpr Error MetalClawReaderTemplate::fieldCString(const char*, char **val, std::size_t buffLen) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::fieldCString(CString, char **val, size_t buffLen) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(size, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(size, mc::decodeInteger(m_reader, bytesRead)); // re-allocate if too small if (buffLen < size + 1) { safeDelete(*val); @@ -420,13 +422,13 @@ constexpr Error MetalClawReaderTemplate::fieldCString(const char*, char } template -constexpr Result MetalClawReaderTemplate::arrayLength(const char*, bool pass) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Result MetalClawReaderTemplate::arrayLength(CString, bool const pass) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; + size_t bytesRead = 0; OX_REQUIRE(g, m_reader.tellg()); - OX_REQUIRE(out, mc::decodeInteger(m_reader, &bytesRead)); + OX_REQUIRE(out, mc::decodeInteger(m_reader, bytesRead)); if (!pass) { OX_RETURN_ERROR(m_reader.seekg(g)); } @@ -437,12 +439,12 @@ constexpr Result MetalClawReaderTemplate::arrayLength(const } template -constexpr Result MetalClawReaderTemplate::stringLength(const char*) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Result MetalClawReaderTemplate::stringLength(CString) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - auto len = mc::decodeInteger(m_reader, &bytesRead); + size_t bytesRead = 0; + auto len = mc::decodeInteger(m_reader, bytesRead); OX_RETURN_ERROR(m_reader.seekg(-static_cast(bytesRead), ox::ios_base::cur)); return len; } @@ -452,15 +454,15 @@ constexpr Result MetalClawReaderTemplate::stringLength(con template template -constexpr Error MetalClawReaderTemplate::readInteger(I *val) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { - std::size_t bytesRead = 0; - auto const result = mc::decodeInteger(m_reader, &bytesRead); +constexpr Error MetalClawReaderTemplate::readInteger(I &val) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { + size_t bytesRead = 0; + auto const result = mc::decodeInteger(m_reader, bytesRead); OX_RETURN_ERROR(result); - *val = result.value; + val = result.value; } else { - *val = 0; + val = 0; } } ++m_field; @@ -469,17 +471,17 @@ constexpr Error MetalClawReaderTemplate::readInteger(I *val) noexcept { template template -constexpr Error MetalClawReaderTemplate::field(const char*, CB cb) noexcept { - if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { - if (m_fieldPresence.get(static_cast(m_field))) { +constexpr Error MetalClawReaderTemplate::field(CString, CB cb) noexcept { + if (!m_unionIdx.has_value() || static_cast(*m_unionIdx) == m_field) { + if (m_fieldPresence.get(static_cast(m_field))) { // read the length - std::size_t bytesRead = 0; - OX_REQUIRE(len, mc::decodeInteger(m_reader, &bytesRead)); + size_t bytesRead = 0; + OX_REQUIRE(len, mc::decodeInteger(m_reader, bytesRead)); // read the list auto reader = child(""); auto &handler = *reader.interface(); - OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast(len))); - for (std::size_t i = 0; i < len; ++i) { + OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast(len))); + for (size_t i = 0; i < len; ++i) { T val; OX_RETURN_ERROR(handler.field("", &val)); OX_RETURN_ERROR(cb(i, &val)); @@ -493,7 +495,7 @@ constexpr Error MetalClawReaderTemplate::field(const char*, CB cb) noexc template template constexpr ox::Error MetalClawReaderTemplate::setTypeInfo( - const char*, int, const Vector&, std::size_t fields) noexcept { + CString, int, const Vector&, size_t const fields) noexcept { m_fields = fields; // Warning: narrow-conv return m_reader.seekg( @@ -503,24 +505,24 @@ constexpr ox::Error MetalClawReaderTemplate::setTypeInfo( template constexpr MetalClawReaderTemplate MetalClawReaderTemplate::child( - const char*, - ox::Optional unionIdx) noexcept { + CString, + Optional const unionIdx) noexcept { return MetalClawReaderTemplate(m_reader, unionIdx); } template -constexpr bool MetalClawReaderTemplate::fieldPresent(const char*) const noexcept { - return m_fieldPresence.get(static_cast(m_field)).value; +constexpr bool MetalClawReaderTemplate::fieldPresent(CString) const noexcept { + return m_fieldPresence.get(static_cast(m_field)).value; } template -constexpr bool MetalClawReaderTemplate::fieldPresent(int fieldNo) const noexcept { - return m_fieldPresence.get(static_cast(fieldNo)).value; +constexpr bool MetalClawReaderTemplate::fieldPresent(int const fieldNo) const noexcept { + return m_fieldPresence.get(static_cast(fieldNo)).value; } template [[nodiscard]] -constexpr int MetalClawReaderTemplate::whichFieldPresent(const char*, const ModelUnion &u) const noexcept { +constexpr int MetalClawReaderTemplate::whichFieldPresent(CString, ModelUnion const &u) const noexcept { FieldBitmapReader p(m_reader); for (auto i = 0u; i < u.fieldCount(); ++i) { if (p.get(i)) { @@ -538,11 +540,10 @@ constexpr void MetalClawReaderTemplate::nextField() noexcept { using MetalClawReader = MetalClawReaderTemplate; template -Error readMC(ox::BufferView buff, T &val) noexcept { +Error readMC(ox::BufferView const buff, T &val) noexcept { BufferReader br(buff); MetalClawReader reader(br); - ModelHandlerInterface handler(&reader); - return model(&handler, &val); + return model(reader.interface(), &val); } template diff --git a/deps/ox/src/ox/mc/write.hpp b/deps/ox/src/ox/mc/write.hpp index 4c836ff7..0e03b7fd 100644 --- a/deps/ox/src/ox/mc/write.hpp +++ b/deps/ox/src/ox/mc/write.hpp @@ -268,7 +268,7 @@ constexpr Error MetalClawWriter::field(const char*, const T *val) noexce if (val && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) { auto const writeIdx = m_writer.tellp(); MetalClawWriter writer(m_writer); - ModelHandlerInterface> handler{&writer}; + ModelHandlerInterface> handler{writer}; OX_RETURN_ERROR(model(&handler, val)); OX_RETURN_ERROR(writer.finalize()); fieldSet = writeIdx != m_writer.tellp(); @@ -286,7 +286,7 @@ constexpr Error MetalClawWriter::field(const char*, UnionView if (val.get() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) { auto const writeIdx = m_writer.tellp(); MetalClawWriter writer(m_writer, ox::Optional(ox::in_place, val.idx())); - ModelHandlerInterface handler{&writer}; + ModelHandlerInterface handler{writer}; OX_RETURN_ERROR(model(&handler, val.get())); OX_RETURN_ERROR(writer.finalize()); fieldSet = writeIdx != m_writer.tellp(); @@ -306,7 +306,7 @@ constexpr Error MetalClawWriter::field(const char*, const T *val, std::s OX_RETURN_ERROR(m_writer.write(reinterpret_cast(arrLen.data.data()), arrLen.length)); auto const writeIdx = m_writer.tellp(); MetalClawWriter writer(m_writer); - ModelHandlerInterface handler{&writer}; + ModelHandlerInterface handler{writer}; OX_RETURN_ERROR(handler.template setTypeInfo("List", 0, {}, static_cast(len))); // write the array for (std::size_t i = 0; i < len; ++i) { @@ -334,7 +334,7 @@ constexpr Error MetalClawWriter::field(const char*, const HashMap(arrLen.data.data()), arrLen.length)); // write map MetalClawWriter writer(m_writer); - ModelHandlerInterface handler{&writer}; + ModelHandlerInterface handler{writer}; // double len for both key and value OX_RETURN_ERROR(handler.setTypeInfo("Map", 0, {}, len * 2)); // this loop body needs to be in a lambda because of the potential alloca call @@ -387,7 +387,7 @@ ox::Error MetalClawWriter::finalize() noexcept { Result writeMC(Writer_c auto &writer, const auto &val) noexcept { MetalClawWriter mcWriter(writer); - ModelHandlerInterface handler{&mcWriter}; + ModelHandlerInterface handler{mcWriter}; OX_RETURN_ERROR(model(&handler, &val)); OX_RETURN_ERROR(mcWriter.finalize()); return {}; diff --git a/deps/ox/src/ox/model/descwrite.hpp b/deps/ox/src/ox/model/descwrite.hpp index b66026ac..1bd5c093 100644 --- a/deps/ox/src/ox/model/descwrite.hpp +++ b/deps/ox/src/ox/model/descwrite.hpp @@ -380,7 +380,7 @@ constexpr const DescriptorType *TypeDescWriter::getType(StringViewCR tn, int typ template constexpr Result buildTypeDef(TypeStore &typeStore) noexcept { TypeDescWriter writer(&typeStore); - ModelHandlerInterface handler(&writer); + ModelHandlerInterface handler(writer); if (std::is_constant_evaluated()) { std::allocator a; T *t = a.allocate(1); @@ -396,7 +396,7 @@ constexpr Result buildTypeDef(TypeStore &typeStore) noexcept { template constexpr Result buildTypeDef(TypeStore &typeStore, T &val) noexcept { TypeDescWriter writer(&typeStore); - ModelHandlerInterface handler(&writer); + ModelHandlerInterface handler(writer); OX_RETURN_ERROR(model(&handler, &val)); return writer.definition(); } diff --git a/deps/ox/src/ox/model/modelhandleradaptor.hpp b/deps/ox/src/ox/model/modelhandleradaptor.hpp index 56f6367a..4589f5b6 100644 --- a/deps/ox/src/ox/model/modelhandleradaptor.hpp +++ b/deps/ox/src/ox/model/modelhandleradaptor.hpp @@ -17,10 +17,10 @@ namespace ox { template class ModelHandlerInterface { private: - Handler *m_handler = nullptr; + Handler &m_handler; public: - constexpr explicit ModelHandlerInterface(Handler *handler) noexcept: m_handler(handler) { + constexpr explicit ModelHandlerInterface(Handler &handler) noexcept: m_handler(handler) { } template @@ -28,7 +28,7 @@ class ModelHandlerInterface { const char* name = T::TypeName, int version = T::TypeVersion, const Vector& typeParams = {}) noexcept { - return m_handler->template setTypeInfo(name, version, typeParams, ModelFieldCount_v); + return m_handler.template setTypeInfo(name, version, typeParams, ModelFieldCount_v); } template @@ -37,31 +37,31 @@ class ModelHandlerInterface { int version, const Vector& typeParams, std::size_t fields) noexcept { - return m_handler->template setTypeInfo(name, version, typeParams, fields); + return m_handler.template setTypeInfo(name, version, typeParams, fields); } template 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 constexpr Error fieldCString(const char *name, const char val[len]) noexcept requires(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 { return {}; } } 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) { // this check looks pointless, but it's to address a Clang bug if constexpr(opType_v != OpType::Read) { - return m_handler->fieldCString(name, val); + return m_handler.fieldCString(name, val); } else { return {}; } @@ -70,27 +70,27 @@ class ModelHandlerInterface { 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 if constexpr(opType_v != OpType::Read) { - return m_handler->fieldCString(name, val); + return m_handler.fieldCString(name, val); } else { return {}; } } 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) { // this check looks pointless, but it's to address a Clang bug if constexpr(opType_v != OpType::Read) { - return m_handler->fieldCString(name, val, buffLen); + return m_handler.fieldCString(name, val, buffLen); } else { return {}; } } 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 auto *v) noexcept { @@ -98,41 +98,41 @@ class ModelHandlerInterface { case ModelValue::Type::Undefined: break; case ModelValue::Type::Bool: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::UnsignedInteger8: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::UnsignedInteger16: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::UnsignedInteger32: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::UnsignedInteger64: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::SignedInteger8: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::SignedInteger16: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::SignedInteger32: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::SignedInteger64: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::String: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::Object: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::Union: { auto &u = v->template get(); if constexpr(opType_v == OpType::Read) { - u.setActiveField(m_handler->whichFieldPresent(name, u)); - return m_handler->field(name, UnionView(&u, u.unionIdx())); + u.setActiveField(m_handler.whichFieldPresent(name, u)); + return m_handler.field(name, UnionView(&u, u.unionIdx())); } else { - return m_handler->field(name, UnionView(&u, u.unionIdx())); + return m_handler.field(name, UnionView(&u, u.unionIdx())); } } case ModelValue::Type::Vector: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); case ModelValue::Type::InlineArray: - return m_handler->field(name, &v->template get()); + return m_handler.field(name, &v->template get()); } oxErrf("invalid type: {}: {}\n", name, static_cast(v->type())); ox::panic("invalid type"); @@ -142,7 +142,7 @@ class ModelHandlerInterface { // array handler, with callback to allow handling individual elements template constexpr Error field(const char *name, Callback cb) noexcept { - return m_handler->template field(name, cb); + return m_handler.template field(name, cb); } template @@ -150,7 +150,7 @@ class ModelHandlerInterface { if constexpr(ox::is_same_v) { return fieldModelValue(name, v); } 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) { return fieldModelValue(name, v); } else { - return m_handler->field(name, v); + return m_handler.field(name, v); } } template constexpr Error field(const char *name, UnionView 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 { - 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. + * @param name * @param pass indicates that the parsing should iterate past the array length */ [[nodiscard]] 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]] constexpr auto stringLength(const char *name) noexcept { - return m_handler->stringLength(name); + return m_handler.stringLength(name); } [[nodiscard]] @@ -200,20 +201,17 @@ class ModelHandlerInterface { } }; -template +template class ModelHandlerBase { private: - ModelHandlerInterface m_interface; + ModelHandlerInterface m_interface{*static_cast(this)}; public: - constexpr ModelHandlerBase() noexcept: m_interface(static_cast(this)) {} - constexpr ModelHandlerBase(const ModelHandlerBase&) noexcept: m_interface(static_cast(this)) {} - constexpr ModelHandlerBase(ModelHandlerBase&&) noexcept: m_interface(static_cast(this)) {} [[nodiscard]] constexpr auto interface() noexcept { return &m_interface; } [[nodiscard]] - static constexpr ox::OpType opType() noexcept { + static constexpr OpType opType() noexcept { return opType_v; } }; diff --git a/deps/ox/src/ox/oc/read.cpp b/deps/ox/src/ox/oc/read.cpp index 38eb1a72..d20749f9 100644 --- a/deps/ox/src/ox/oc/read.cpp +++ b/deps/ox/src/ox/oc/read.cpp @@ -13,31 +13,31 @@ 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(buff); auto jsonLen = ox::strnlen_s(json, buffSize); Json::CharReaderBuilder parserBuilder; auto parser = std::unique_ptr(parserBuilder.newCharReader()); 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; auto parser = std::unique_ptr(parserBuilder.newCharReader()); 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_unionIdx(unionIdx) { } -Error OrganicClawReader::field(const char *key, bool *val) noexcept { - ox::Error err{}; +Error OrganicClawReader::field(CString const key, bool *val) noexcept { + Error err{}; if (targetValid()) { const auto &jv = value(key); if (jv.empty()) { @@ -45,16 +45,16 @@ Error OrganicClawReader::field(const char *key, bool *val) noexcept { } else if (jv.isBool()) { *val = jv.asBool(); } else { - err = ox::Error(1, "Type mismatch"); + err = Error(1, "Type mismatch"); } } ++m_fieldIt; return err; } -Error OrganicClawReader::fieldCString(const char *key, char *val, std::size_t buffLen) noexcept { - ox::Error err{}; - const char *begin = nullptr, *end = nullptr; +Error OrganicClawReader::fieldCString(CString const key, char *val, size_t const buffLen) noexcept { + Error err{}; + CString begin = nullptr, end = nullptr; const auto &jv = value(key); if (targetValid()) { if (jv.empty()) { @@ -64,25 +64,25 @@ Error OrganicClawReader::fieldCString(const char *key, char *val, std::size_t bu } } else if (jv.isString()) { jv.getString(&begin, &end); - const auto strSize = static_cast(end - begin); + const auto strSize = static_cast(end - begin); auto data = val; if (strSize >= buffLen) { - err = ox::Error(2, "String size exceeds capacity of destination"); + err = Error(2, "String size exceeds capacity of destination"); } else { - ox::memcpy(data, begin, static_cast(strSize)); + memcpy(data, begin, static_cast(strSize)); data[strSize] = 0; } } else { - err = ox::Error(1, "Type mismatch"); + err = Error(1, "Type mismatch"); } } ++m_fieldIt; return err; } -Error OrganicClawReader::fieldCString(const char *key, char **val) noexcept { - ox::Error err{}; - const char *begin = nullptr, *end = nullptr; +Error OrganicClawReader::fieldCString(CString const key, char **val) noexcept { + Error err{}; + CString begin = nullptr, end = nullptr; const auto &jv = value(key); auto &data = *val; if (targetValid()) { @@ -92,22 +92,22 @@ Error OrganicClawReader::fieldCString(const char *key, char **val) noexcept { } } else if (jv.isString()) { jv.getString(&begin, &end); - const auto strSize = static_cast(end - begin); + const auto strSize = static_cast(end - begin); safeDelete(*val); *val = new char[strSize + 1]; - ox::memcpy(data, begin, static_cast(strSize)); + memcpy(data, begin, static_cast(strSize)); data[strSize] = 0; } else { - err = ox::Error(1, "Type mismatch"); + err = Error(1, "Type mismatch"); } } ++m_fieldIt; return err; } -Error OrganicClawReader::fieldCString(const char *key, char **val, std::size_t buffLen) noexcept { - ox::Error err{}; - const char *begin = nullptr, *end = nullptr; +Error OrganicClawReader::fieldCString(CString const key, char **val, size_t const buffLen) noexcept { + Error err{}; + CString begin = nullptr, end = nullptr; const auto &jv = value(key); if (targetValid()) { if (jv.empty()) { @@ -117,29 +117,29 @@ Error OrganicClawReader::fieldCString(const char *key, char **val, std::size_t b } } else if (jv.isString()) { jv.getString(&begin, &end); - const auto strSize = static_cast(end - begin); + const auto strSize = static_cast(end - begin); auto data = val; if (strSize >= buffLen) { safeDelete(*val); *val = new char[strSize + 1]; } - ox::memcpy(data, begin, static_cast(strSize)); + memcpy(data, begin, static_cast(strSize)); data[strSize] = nullptr; } else { - err = ox::Error(1, "Type mismatch"); + err = Error(1, "Type mismatch"); } } ++m_fieldIt; return err; } -Error OrganicClawReader::field(const char *key, UUID *val) noexcept { +Error OrganicClawReader::field(CString const key, UUID *val) noexcept { UUIDStr str; OX_RETURN_ERROR(field(key, &str)); return UUID::fromString(str).moveTo(*val); } -Result OrganicClawReader::arrayLength(const char *key, bool) noexcept { +Result OrganicClawReader::arrayLength(CString const key, bool) noexcept { const auto &jv = value(key); if (jv.empty()) { return 0; @@ -147,32 +147,32 @@ Result OrganicClawReader::arrayLength(const char *key, bool) noexce if (jv.isArray()) { return jv.size(); } - return ox::Error(1, "Type mismatch"); + return Error(1, "Type mismatch"); } [[nodiscard]] -std::size_t OrganicClawReader::stringLength(const char *key) noexcept { - const char *begin = nullptr, *end = nullptr; +size_t OrganicClawReader::stringLength(CString const key) noexcept { + CString begin = nullptr, end = nullptr; const auto &jv = value(key); if (jv.empty()) { return 0; } if (jv.isString()) { jv.getString(&begin, &end); - return static_cast(end - begin); + return static_cast(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); } -bool OrganicClawReader::fieldPresent(const char *key) noexcept { +bool OrganicClawReader::fieldPresent(CString const key) noexcept { 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]; if (!obj.isObject()) { return -1; @@ -184,7 +184,7 @@ int OrganicClawReader::whichFieldPresent(const char *name, const ModelUnion &u) 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()) { return m_json[m_fieldIt]; } else { diff --git a/deps/ox/src/ox/oc/read.hpp b/deps/ox/src/ox/oc/read.hpp index cb7c9af9..973bcdab 100644 --- a/deps/ox/src/ox/oc/read.hpp +++ b/deps/ox/src/ox/oc/read.hpp @@ -34,75 +34,76 @@ class OrganicClawReader { private: Json::Value m_json; Json::ArrayIndex m_fieldIt = 0; - int m_unionIdx = -1; + int const m_unionIdx = -1; public: 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; - Error field(const char *key, bool *val) noexcept; + Error field(CString key, bool *val) noexcept; // array handler template - Error field(const char *key, T *val, std::size_t len) noexcept; + Error field(CString key, T *val, size_t len) noexcept; template - Error field(const char*, HashMap *val) noexcept; + Error field(CString, HashMap *val) noexcept; template - Error field(const char *key, T *val) noexcept; + Error field(CString key, T *val) noexcept; template - Error field(const char *key, UnionView val) noexcept; + Error field(CString key, UnionView val) noexcept; - template - Error field(const char *key, BasicString *val) noexcept; + template + Error field(CString key, BasicString *val) noexcept; - template - Error field(const char *key, IString *val) noexcept; + template + Error field(CString key, IString *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. + * @param key * @param pass indicates that the parsing should iterate past the array length */ - Result arrayLength(const char *key, bool pass = true) noexcept; + Result arrayLength(CString key, bool pass = true) noexcept; /** * Reads an string length from the current location in the buffer. */ [[nodiscard]] - std::size_t stringLength(const char *name) noexcept; + size_t stringLength(CString key) noexcept; template - constexpr ox::Error setTypeInfo() noexcept { + constexpr Error setTypeInfo() noexcept { return {}; } template - constexpr ox::Error setTypeInfo(const char*) noexcept { + constexpr Error setTypeInfo(CString) noexcept { return {}; } template - constexpr ox::Error setTypeInfo(const char*, int, const Vector& = {}) noexcept { + constexpr Error setTypeInfo(CString, int, const Vector& = {}) noexcept { return {}; } template - constexpr ox::Error setTypeInfo(const char*, int, const Vector& = {}, std::size_t = {}) noexcept { + constexpr Error setTypeInfo(CString, int, const Vector& = {}, size_t = {}) noexcept { return {}; } @@ -110,16 +111,16 @@ class OrganicClawReader { * Returns a OrganicClawReader to parse a child object. */ [[nodiscard]] - OrganicClawReader child(const char *key, int unionIdx = -1) noexcept; + OrganicClawReader child(CString key, int unionIdx = -1) noexcept; // compatibility stub constexpr void nextField() noexcept {} [[nodiscard]] - bool fieldPresent(const char *key) noexcept; + bool fieldPresent(CString key) noexcept; [[nodiscard]] - int whichFieldPresent(const char *name, const ModelUnion &u) const noexcept; + int whichFieldPresent(CString name, const ModelUnion &u) const noexcept; [[nodiscard]] static constexpr auto opType() noexcept { @@ -128,7 +129,7 @@ class OrganicClawReader { private: [[nodiscard]] - Json::Value &value(const char *key) noexcept; + Json::Value &value(CString key) noexcept; [[nodiscard]] bool targetValid() const noexcept; @@ -136,102 +137,102 @@ class OrganicClawReader { }; template -Error OrganicClawReader::field(const char *key, T *val) noexcept { - ox::Error err{}; +Error OrganicClawReader::field(CString key, T *val) noexcept { + Error err{}; try { if constexpr (is_integer_v) { if (targetValid()) { - auto const&jv = value(key); + auto const &jv = value(key); auto const rightType = sizeof(T) == 8 ? - (ox::is_signed_v ? jv.isInt64() : jv.isUInt64()) : - (ox::is_signed_v ? jv.isInt() : jv.isUInt()); + (is_signed_v ? jv.isInt64() : jv.isUInt64()) : + (is_signed_v ? jv.isInt() : jv.isUInt()); if (jv.empty()) { *val = 0; } else if (rightType) { - if constexpr(ox::is_signed_v) { + if constexpr(is_signed_v) { *val = static_cast(jv.asInt64()); } else { *val = static_cast(jv.asUInt64()); } } else { - err = ox::Error(1, "Type mismatch"); + err = Error{1, "Type mismatch"}; } } } else if constexpr (isVector_v) { - const auto&srcVal = value(key); - const auto srcSize = srcVal.size(); - OX_RETURN_ERROR(ox::resizeVector(*val, srcSize)); + auto const &srcVal = value(key); + auto const srcSize = srcVal.size(); + OX_RETURN_ERROR(resizeVector(*val, srcSize)); err = field(key, val->data(), val->size()); } else if constexpr (isArray_v) { - const auto&srcVal = value(key); - const auto srcSize = srcVal.size(); + auto const &srcVal = value(key); + auto const srcSize = srcVal.size(); if (srcSize > val->size()) { - err = ox::Error(1, "Input array is too long"); + err = Error{1, "Input array is too long"}; } else { err = field(key, val->data(), val->size()); } } else if (targetValid()) { - const auto&jv = value(key); + auto const &jv = value(key); if (jv.empty() || jv.isObject()) { auto reader = child(key); - ModelHandlerInterface handler(&reader); + ModelHandlerInterface handler(reader); err = model(&handler, val); } else { - err = ox::Error(1, "Type mismatch"); + err = Error{1, "Type mismatch"}; } } - } catch (Json::LogicError const&e) { - err = ox::Error(1, "error reading JSON data"); + } catch (Json::LogicError const &e) { + err = Error{1, "error reading JSON data"}; } ++m_fieldIt; return err; } template -Error OrganicClawReader::field(const char *key, UnionView val) noexcept { - ox::Error err{}; +Error OrganicClawReader::field(CString const key, UnionView val) noexcept { + Error err{}; if (targetValid()) { - const auto &jv = value(key); + auto const &jv = value(key); if (jv.empty() || jv.isObject()) { auto reader = child(key, val.idx()); - ModelHandlerInterface handler(&reader); + ModelHandlerInterface handler(reader); err = model(&handler, val.get()); } else { - err = ox::Error(1, "Type mismatch"); + err = Error{1, "Type mismatch"}; } } ++m_fieldIt; return err; } -template -Error OrganicClawReader::field(const char *key, BasicString *val) noexcept { - ox::Error err{}; +template +Error OrganicClawReader::field(CString const key, BasicString *val) noexcept { + Error err{}; if (targetValid()) { - const auto &jv = value(key); + auto const &jv = value(key); if (jv.empty()) { *val = BasicString{}; } else if (jv.isString()) { *val = jv.asString().c_str(); } else { - err = ox::Error(1, "Type mismatch"); + err = Error{1, "Type mismatch"}; } } ++m_fieldIt; return err; } -template -Error OrganicClawReader::field(const char *key, IString *val) noexcept { - ox::Error err{}; +template +Error OrganicClawReader::field(CString const key, IString *val) noexcept { + Error err{}; if (targetValid()) { - const auto &jv = value(key); + auto const &jv = value(key); if (jv.empty()) { *val = IString{}; } else if (jv.isString()) { *val = jv.asString().c_str(); } else { - err = ox::Error(1, "Type mismatch"); + err = Error{1, "Type mismatch"}; } } ++m_fieldIt; @@ -240,17 +241,17 @@ Error OrganicClawReader::field(const char *key, IString *val) noexcept { // array handler template -Error OrganicClawReader::field(const char *key, T *val, std::size_t valLen) noexcept { - const auto &srcVal = value(key); +Error OrganicClawReader::field(CString const key, T *val, size_t valLen) noexcept { + auto const &srcVal = value(key); if (!srcVal.isNull() && !srcVal.isArray()) { - return ox::Error(1, "Type mismatch"); + return Error{1, "Type mismatch"}; } auto srcSize = srcVal.size(); if (srcSize > valLen) { - return ox::Error(1); + return Error{1}; } OrganicClawReader r(srcVal); - ModelHandlerInterface handler{&r}; + ModelHandlerInterface handler{r}; for (decltype(srcSize) i = 0; i < srcSize; ++i) { OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_RETURN_ERROR(handler.field("", &val[i])); @@ -260,23 +261,23 @@ OX_ALLOW_UNSAFE_BUFFERS_END } template -Error OrganicClawReader::field(const char *key, HashMap *val) noexcept { - const auto &srcVal = value(key); +Error OrganicClawReader::field(CString const key, HashMap *val) noexcept { + auto const &srcVal = value(key); if (!srcVal.isObject()) { - return ox::Error(1, "Type mismatch"); + return Error{1, "Type mismatch"}; } auto keys = srcVal.getMemberNames(); auto srcSize = srcVal.size(); OrganicClawReader r(srcVal); - ModelHandlerInterface handler{&r}; + ModelHandlerInterface handler{r}; 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))); } 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. try { Json::Value doc; @@ -285,15 +286,15 @@ Error readOC(BufferView buff, auto &val) noexcept { OX_ALLOW_UNSAFE_BUFFERS_BEGIN if (!parser->parse(buff.data(), buff.data() + buff.size(), &doc, nullptr)) { 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()); - ModelHandlerInterface handler(&reader); + ModelHandlerInterface handler(reader); return model(&handler, &val); - } catch (const Error &err) { + } catch (Error const &err) { return err; } catch (...) { - return ox::Error(1, "Unknown Error"); + return Error{1, "Unknown Error"}; } } @@ -305,8 +306,8 @@ Result readOC(BufferView buff) noexcept { } template -Result readOC(ox::StringView json) noexcept { - return readOC(ox::BufferView{json.data(), json.size()}); +Result readOC(StringViewCR json) noexcept { + return readOC(BufferView{json.data(), json.size()}); } } diff --git a/deps/ox/src/ox/oc/write.cpp b/deps/ox/src/ox/oc/write.cpp index 3e27a03e..618b930f 100644 --- a/deps/ox/src/ox/oc/write.cpp +++ b/deps/ox/src/ox/oc/write.cpp @@ -10,15 +10,15 @@ 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_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) { value(key) = *val; } @@ -26,11 +26,11 @@ Error OrganicClawWriter::fieldCString(const char *key, const char *const*val, in 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(val), static_cast(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(); if (targetValid() && uuidStr.size()) { value(key) = uuidStr.c_str(); diff --git a/deps/ox/src/ox/oc/write.hpp b/deps/ox/src/ox/oc/write.hpp index b8ca98e9..1f22db2d 100644 --- a/deps/ox/src/ox/oc/write.hpp +++ b/deps/ox/src/ox/oc/write.hpp @@ -28,20 +28,20 @@ namespace ox { class OrganicClawWriter { - friend Result writeOC(const auto &val) noexcept; - friend Result writeOCString(const auto &val) noexcept; + friend Result writeOC(const auto &val) noexcept; + friend Result writeOCString(const auto &val) noexcept; protected: Json::Value m_json{Json::Value(Json::objectValue)}; Json::ArrayIndex m_fieldIt = 0; - int m_unionIdx = -1; + int const m_unionIdx = -1; public: explicit OrganicClawWriter(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())) { value(key) = *val; } @@ -49,7 +49,7 @@ class OrganicClawWriter { 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())) { value(key) = *val; } @@ -57,7 +57,7 @@ class OrganicClawWriter { 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())) { value(key) = *val; } @@ -65,7 +65,7 @@ class OrganicClawWriter { 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())) { 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())) { value(key) = *val; } @@ -82,7 +82,7 @@ class OrganicClawWriter { 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())) { value(key) = *val; } @@ -90,7 +90,7 @@ class OrganicClawWriter { 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())) { value(key) = *val; } @@ -98,7 +98,7 @@ class OrganicClawWriter { 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())) { value(key) = *val; } @@ -106,7 +106,7 @@ class OrganicClawWriter { 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())) { value(key) = *val; } @@ -118,12 +118,12 @@ class OrganicClawWriter { Error field(char const*, UnionView val) noexcept; template - Error field(char const*key, HashMap const*val) noexcept { + Error field(char const*key, HashMap const *val) noexcept { if (targetValid()) { const auto &keys = val->keys(); OrganicClawWriter w; - ModelHandlerInterface handler{&w}; - for (std::size_t i = 0; i < keys.size(); ++i) { + ModelHandlerInterface handler{w}; + for (size_t i = 0; i < keys.size(); ++i) { const auto k = keys[i].c_str(); if (k) [[likely]] { OX_REQUIRE_M(value, val->at(k)); @@ -136,8 +136,8 @@ class OrganicClawWriter { return {}; } - template - Error field(char const*key, IString const*val) noexcept { + template + Error field(char const*key, IString const *val) noexcept { if (targetValid() && val->size()) { value(key) = val->c_str(); } @@ -145,8 +145,8 @@ class OrganicClawWriter { return {}; } - template - Error field(char const*key, BasicString const*val) noexcept { + template + Error field(char const*key, BasicString const *val) noexcept { if (targetValid() && val->size()) { value(key) = val->c_str(); } @@ -154,31 +154,31 @@ class OrganicClawWriter { 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 field(const char *key, const UUID *uuid) noexcept; + Error field(const char *key, UUID const *uuid) noexcept; template - Error field(const char*, const T *val, std::size_t len) noexcept; + Error field(const char*, T const *val, size_t len) noexcept; template - Error field(const char*, const T *val) noexcept; + Error field(const char*, T const *val) noexcept; template - constexpr ox::Error setTypeInfo( + constexpr Error setTypeInfo( const char* = T::TypeName, int = T::TypeVersion) noexcept { return {}; } template - constexpr ox::Error setTypeInfo( + constexpr Error setTypeInfo( const char*, int, - const Vector&, - std::size_t) noexcept { + Vector const&, + size_t) noexcept { return {}; } @@ -199,11 +199,11 @@ class OrganicClawWriter { }; template -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) { OrganicClawWriter w((Json::Value(Json::arrayValue))); - ModelHandlerInterface handler{&w}; - for (std::size_t i = 0; i < len; ++i) { + ModelHandlerInterface handler{w}; + for (size_t i = 0; i < len; ++i) { OX_ALLOW_UNSAFE_BUFFERS_BEGIN OX_RETURN_ERROR(handler.field({}, &val[i])); OX_ALLOW_UNSAFE_BUFFERS_END @@ -215,22 +215,22 @@ OX_ALLOW_UNSAFE_BUFFERS_END } template -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) { if (targetValid() && (*val || m_json.isArray())) { // the int type needs to be normalized because jsoncpp doesn't // factor in every permutation unsigned long, etc. - if constexpr(ox::is_signed_v) { - value(key) = static_cast>(*val); + if constexpr(is_signed_v) { + value(key) = static_cast>(*val); } else { - value(key) = static_cast>(*val); + value(key) = static_cast>(*val); } } } else if constexpr(isVector_v || isArray_v) { return field(key, val->data(), val->size()); } else if (val && targetValid()) { OrganicClawWriter w; - ModelHandlerInterface handler{&w}; + ModelHandlerInterface handler{w}; OX_RETURN_ERROR(model(&handler, val)); if (!w.m_json.empty() || m_json.isArray()) { value(key) = w.m_json; @@ -244,7 +244,7 @@ template Error OrganicClawWriter::field(const char *key, UnionView val) noexcept { if (targetValid()) { OrganicClawWriter w(val.idx()); - ModelHandlerInterface handler{&w}; + ModelHandlerInterface handler{w}; OX_RETURN_ERROR(model(&handler, val.get())); if (!w.m_json.isNull()) { value(key) = w.m_json; @@ -254,12 +254,12 @@ Error OrganicClawWriter::field(const char *key, UnionView val) noexcep return {}; } -Result writeOC(const auto &val) noexcept { +Result writeOC(auto const &val) noexcept { OrganicClawWriter writer; - ModelHandlerInterface handler(&writer); + ModelHandlerInterface handler(writer); OX_RETURN_ERROR(model(&handler, &val)); Json::StreamWriterBuilder const jsonBuilder; - const auto str = Json::writeString(jsonBuilder, writer.m_json); + auto const str = Json::writeString(jsonBuilder, writer.m_json); Result buff; buff.value.resize(str.size() + 1); OX_ALLOW_UNSAFE_BUFFERS_BEGIN @@ -268,13 +268,13 @@ Result writeOC(const auto &val) noexcept { return buff; } -Result writeOCString(const auto &val) noexcept { +Result writeOCString(auto const &val) noexcept { OrganicClawWriter writer; - ModelHandlerInterface handler(&writer); + ModelHandlerInterface handler(writer); OX_RETURN_ERROR(model(&handler, &val)); Json::StreamWriterBuilder const jsonBuilder; - const auto str = Json::writeString(jsonBuilder, writer.m_json); - Result buff; + auto const str = Json::writeString(jsonBuilder, writer.m_json); + Result buff; buff.value.resize(str.size()); OX_ALLOW_UNSAFE_BUFFERS_BEGIN memcpy(buff.value.data(), str.data(), str.size() + 1);