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});
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

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});
MetalClawReader reader(br);
ModelHandlerInterface handler(&reader);
return model(&handler, &val);
return model(reader.interface(), &val);
}
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);
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;
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<I>(out);
}
*bytesRead = bytes;
bytesRead = bytes;
uint64_t decoded = 0;
OX_RETURN_ERROR(rdr.read(&decoded, bytes));
decoded >>= bytes;
@@ -196,7 +196,7 @@ template<typename I>
Result<I> decodeInteger(McInt m) noexcept {
std::size_t bytesRead{};
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:
FieldBitmapReader<Reader> m_fieldPresence;
std::size_t m_fields = 0;
std::size_t m_field = 0;
ox::Optional<int> m_unionIdx;
size_t m_fields{};
size_t m_field{};
Optional<int> const m_unionIdx{};
Reader &m_reader;
public:
explicit constexpr MetalClawReaderTemplate(
Reader &reader,
ox::Optional<int> const&unionIdx = {}) noexcept;
Optional<int> 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<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
template<typename T, typename CB>
constexpr Error field(const char*, CB cb) noexcept;
constexpr Error field(CString, CB cb) noexcept;
template<typename T>
constexpr Error field(const char*, T *val) noexcept;
constexpr Error field(CString, T *val) noexcept;
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>
constexpr Error field(const char*, BasicString<SmallStringSize> *val) noexcept;
template<size_t SmallStringSize>
constexpr Error field(CString, BasicString<SmallStringSize> *val) noexcept;
template<std::size_t L>
constexpr Error field(const char*, IString<L> *val) noexcept;
template<size_t L>
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.
@@ -101,13 +101,13 @@ class MetalClawReaderTemplate: public ModelHandlerBase<MetalClawReaderTemplate<R
const char *name = T::TypeName,
int version = T::TypeVersion,
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.
*/
[[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.
@@ -122,20 +122,20 @@ class MetalClawReaderTemplate: public ModelHandlerBase<MetalClawReaderTemplate<R
constexpr bool fieldPresent(int fieldNo) const noexcept;
[[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;
private:
template<typename I>
constexpr Error readInteger(I *val) noexcept;
constexpr Error readInteger(I &val) noexcept;
};
template<Reader_c Reader>
constexpr MetalClawReaderTemplate<Reader>::MetalClawReaderTemplate(
Reader &reader,
ox::Optional<int> const&unionIdx) noexcept:
Optional<int> const &unionIdx) noexcept:
m_fieldPresence(reader),
m_unionIdx(unionIdx),
m_reader(reader) {
@@ -149,50 +149,50 @@ constexpr MetalClawReaderTemplate<Reader>::~MetalClawReaderTemplate() noexcept {
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int8_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int8_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int16_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int16_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int32_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int32_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int64_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, int64_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint8_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint8_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint16_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint16_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint32_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint32_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint64_t *val) noexcept {
return readInteger(val);
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, uint64_t *val) noexcept {
return readInteger(*val);
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, bool *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
auto const result = m_fieldPresence.get(static_cast<std::size_t>(m_field));
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, bool *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
auto const result = m_fieldPresence.get(static_cast<size_t>(m_field));
*val = result.value;
OX_RETURN_ERROR(result);
}
@@ -202,18 +202,19 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, bool *val) n
// array handler
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, auto *val, std::size_t valLen) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::field(
const char *name, auto *val, size_t const valLen) noexcept {
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
std::size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(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<std::size_t>(len)));
for (std::size_t i = 0; i < len; ++i) {
OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<size_t>(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<Reader_c Reader>
template<typename T>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, HashMap<String, T> *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, HashMap<String, T> *val) noexcept {
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
OX_REQUIRE(g, m_reader.tellg());
std::size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(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<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
constexpr auto loopBody = [](auto &handler, auto &val) {
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));
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));
}
}
@@ -263,9 +264,9 @@ template<Reader_c Reader>
template<typename T>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val) noexcept {
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
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_RETURN_ERROR(ox::resizeVector(*val, len));
return field(name, val->data(), val->size());
@@ -275,9 +276,9 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val)
++m_field;
return {};
} 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
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));
if (len > val->size()) {
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;
return {};
} else {
if ((!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) && val) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
if ((!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) && val) {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
auto reader = child("");
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<typename U, bool force>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, UnionView<U, force> val) noexcept {
if ((!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) && val.get()) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, UnionView<U, force> val) noexcept {
if ((!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) && val.get()) {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
auto reader = child("", ox::Optional<int>(ox::in_place, val.idx()));
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<std::size_t SmallStringSize>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, BasicString<SmallStringSize> *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
template<size_t SmallStringSize>
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, BasicString<SmallStringSize> *val) noexcept {
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
std::size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
const auto cap = size;
*val = BasicString<SmallStringSize>(cap);
auto data = val->data();
@@ -334,13 +335,13 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, BasicString<
}
template<Reader_c Reader>
template<std::size_t L>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, IString<L> *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
template<size_t L>
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, IString<L> *val) noexcept {
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
std::size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
*val = IString<L>();
OX_RETURN_ERROR(val->resize(size));
auto const data = val->data();
@@ -355,11 +356,12 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, IString<L> *
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char *val, std::size_t buffLen) noexcept {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(
CString, char *val, size_t const buffLen) noexcept {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length
std::size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
if (size > buffLen) {
return ox::Error(McOutputBuffEnded);
}
@@ -374,11 +376,11 @@ constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char **val) noexcept {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(CString, char **val) noexcept {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
// read the length
std::size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
// re-allocate in case too small
safeDelete(*val);
*val = new char[size + 1];
@@ -392,12 +394,12 @@ constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char
}
template<Reader_c Reader>
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char **val, std::size_t buffLen) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(CString, char **val, size_t buffLen) noexcept {
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
std::size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(size, mc::decodeInteger<StringLength>(m_reader, bytesRead));
// re-allocate if too small
if (buffLen < size + 1) {
safeDelete(*val);
@@ -420,13 +422,13 @@ constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char
}
template<Reader_c Reader>
constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(const char*, bool pass) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(CString, bool const pass) noexcept {
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
std::size_t bytesRead = 0;
size_t bytesRead = 0;
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) {
OX_RETURN_ERROR(m_reader.seekg(g));
}
@@ -437,12 +439,12 @@ constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(const
}
template<Reader_c Reader>
constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(const char*) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(CString) noexcept {
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
std::size_t bytesRead = 0;
auto len = mc::decodeInteger<StringLength>(m_reader, &bytesRead);
size_t bytesRead = 0;
auto len = mc::decodeInteger<StringLength>(m_reader, bytesRead);
OX_RETURN_ERROR(m_reader.seekg(-static_cast<int64_t>(bytesRead), ox::ios_base::cur));
return len;
}
@@ -452,15 +454,15 @@ constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(con
template<Reader_c Reader>
template<typename I>
constexpr Error MetalClawReaderTemplate<Reader>::readInteger(I *val) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
std::size_t bytesRead = 0;
auto const result = mc::decodeInteger<I>(m_reader, &bytesRead);
constexpr Error MetalClawReaderTemplate<Reader>::readInteger(I &val) noexcept {
if (!m_unionIdx.has_value() || static_cast<size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<size_t>(m_field))) {
size_t bytesRead = 0;
auto const result = mc::decodeInteger<I>(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<Reader>::readInteger(I *val) noexcept {
template<Reader_c Reader>
template<typename T, typename CB>
constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, CB cb) noexcept {
if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
constexpr Error MetalClawReaderTemplate<Reader>::field(CString, CB cb) noexcept {
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
std::size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
size_t bytesRead = 0;
OX_REQUIRE(len, mc::decodeInteger<ArrayLength>(m_reader, bytesRead));
// read the list
auto reader = child("");
auto &handler = *reader.interface();
OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len)));
for (std::size_t i = 0; i < len; ++i) {
OX_RETURN_ERROR(handler.setTypeInfo("List", 0, {}, static_cast<size_t>(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<Reader>::field(const char*, CB cb) noexc
template<Reader_c Reader>
template<typename T>
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;
// Warning: narrow-conv
return m_reader.seekg(
@@ -503,24 +505,24 @@ constexpr ox::Error MetalClawReaderTemplate<Reader>::setTypeInfo(
template<Reader_c Reader>
constexpr MetalClawReaderTemplate<Reader> MetalClawReaderTemplate<Reader>::child(
const char*,
ox::Optional<int> unionIdx) noexcept {
CString,
Optional<int> const unionIdx) noexcept {
return MetalClawReaderTemplate<Reader>(m_reader, unionIdx);
}
template<Reader_c Reader>
constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(const char*) const noexcept {
return m_fieldPresence.get(static_cast<std::size_t>(m_field)).value;
constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(CString) const noexcept {
return m_fieldPresence.get(static_cast<size_t>(m_field)).value;
}
template<Reader_c Reader>
constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(int fieldNo) const noexcept {
return m_fieldPresence.get(static_cast<std::size_t>(fieldNo)).value;
constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(int const fieldNo) const noexcept {
return m_fieldPresence.get(static_cast<size_t>(fieldNo)).value;
}
template<Reader_c Reader>
[[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);
for (auto i = 0u; i < u.fieldCount(); ++i) {
if (p.get(i)) {
@@ -538,11 +540,10 @@ constexpr void MetalClawReaderTemplate<Reader>::nextField() noexcept {
using MetalClawReader = MetalClawReaderTemplate<ox::BufferReader>;
template<typename T>
Error readMC(ox::BufferView buff, T &val) noexcept {
Error readMC(ox::BufferView const buff, T &val) noexcept {
BufferReader br(buff);
MetalClawReader reader(br);
ModelHandlerInterface<MetalClawReader, ox::OpType::Read> handler(&reader);
return model(&handler, &val);
return model(reader.interface(), &val);
}
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)) {
auto const writeIdx = m_writer.tellp();
MetalClawWriter<Writer> writer(m_writer);
ModelHandlerInterface<MetalClawWriter<Writer>> handler{&writer};
ModelHandlerInterface<MetalClawWriter<Writer>> 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<Writer>::field(const char*, UnionView<U, force>
if (val.get() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
auto const writeIdx = m_writer.tellp();
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(writer.finalize());
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));
auto const writeIdx = m_writer.tellp();
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)));
// write the array
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));
// write map
MetalClawWriter<Writer> 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<Writer>::finalize() noexcept {
Result<Buffer> 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 {};

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>
constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore) noexcept {
TypeDescWriter writer(&typeStore);
ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(&writer);
ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(writer);
if (std::is_constant_evaluated()) {
std::allocator<T> a;
T *t = a.allocate(1);
@@ -396,7 +396,7 @@ constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore) noexcept {
template<typename T>
constexpr Result<DescriptorType*> buildTypeDef(TypeStore &typeStore, T &val) noexcept {
TypeDescWriter writer(&typeStore);
ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(&writer);
ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(writer);
OX_RETURN_ERROR(model(&handler, &val));
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()>
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<typename T = std::nullptr_t>
@@ -28,7 +28,7 @@ class ModelHandlerInterface {
const char* name = T::TypeName,
int version = T::TypeVersion,
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>
@@ -37,31 +37,31 @@ class ModelHandlerInterface {
int version,
const Vector<String>& typeParams,
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>
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>
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<ModelValue> 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<bool>());
return m_handler.field(name, &v->template get<bool>());
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:
return m_handler->field(name, &v->template get<uint16_t>());
return m_handler.field(name, &v->template get<uint16_t>());
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:
return m_handler->field(name, &v->template get<uint64_t>());
return m_handler.field(name, &v->template get<uint64_t>());
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:
return m_handler->field(name, &v->template get<int16_t>());
return m_handler.field(name, &v->template get<int16_t>());
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:
return m_handler->field(name, &v->template get<int64_t>());
return m_handler.field(name, &v->template get<int64_t>());
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:
return m_handler->field(name, &v->template get<ModelObject>());
return m_handler.field(name, &v->template get<ModelObject>());
case ModelValue::Type::Union:
{
auto &u = v->template get<ModelUnion>();
if constexpr(opType_v == OpType::Read) {
u.setActiveField(m_handler->whichFieldPresent(name, u));
return m_handler->field(name, UnionView<ModelUnion, true>(&u, u.unionIdx()));
u.setActiveField(m_handler.whichFieldPresent(name, u));
return m_handler.field(name, UnionView<ModelUnion, true>(&u, u.unionIdx()));
} 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:
return m_handler->field(name, &v->template get<ModelValueVector>());
return m_handler.field(name, &v->template get<ModelValueVector>());
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()));
ox::panic("invalid type");
@@ -142,7 +142,7 @@ class ModelHandlerInterface {
// array handler, with callback to allow handling individual elements
template<typename T, typename Callback>
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>
@@ -150,7 +150,7 @@ class ModelHandlerInterface {
if constexpr(ox::is_same_v<T, ModelValue>) {
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<T, ModelValue>) {
return fieldModelValue(name, v);
} else {
return m_handler->field(name, v);
return m_handler.field(name, v);
}
}
template<typename U, bool force = false>
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 {
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<typename Handler, ox::OpType opType_v = Handler::opType()>
template<typename Handler, OpType opType_v = Handler::opType()>
class ModelHandlerBase {
private:
ModelHandlerInterface<Handler, opType_v> m_interface;
ModelHandlerInterface<Handler, opType_v> m_interface{*static_cast<Handler*>(this)};
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]]
constexpr auto interface() noexcept {
return &m_interface;
}
[[nodiscard]]
static constexpr ox::OpType opType() noexcept {
static constexpr OpType opType() noexcept {
return opType_v;
}
};

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

@@ -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<const char*>(buff);
auto jsonLen = ox::strnlen_s(json, buffSize);
Json::CharReaderBuilder parserBuilder;
auto parser = std::unique_ptr<Json::CharReader>(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<Json::CharReader>(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<std::size_t>(end - begin);
const auto strSize = static_cast<size_t>(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<std::size_t>(strSize));
memcpy(data, begin, static_cast<size_t>(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<std::size_t>(end - begin);
const auto strSize = static_cast<size_t>(end - begin);
safeDelete(*val);
*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;
} 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<std::size_t>(end - begin);
const auto strSize = static_cast<size_t>(end - begin);
auto data = val;
if (strSize >= buffLen) {
safeDelete(*val);
*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;
} 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<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);
if (jv.empty()) {
return 0;
@@ -147,32 +147,32 @@ Result<std::size_t> 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<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);
}
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 {

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

@@ -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<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>
Error field(const char*, HashMap<String, T> *val) noexcept;
Error field(CString, HashMap<String, T> *val) noexcept;
template<typename T>
Error field(const char *key, T *val) noexcept;
Error field(CString key, T *val) noexcept;
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>
Error field(const char *key, BasicString<L> *val) noexcept;
template<size_t L>
Error field(CString key, BasicString<L> *val) noexcept;
template<std::size_t L>
Error field(const char *key, IString<L> *val) noexcept;
template<size_t L>
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.
* @param key
* @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.
*/
[[nodiscard]]
std::size_t stringLength(const char *name) noexcept;
size_t stringLength(CString key) noexcept;
template<typename T = void>
constexpr ox::Error setTypeInfo() noexcept {
constexpr Error setTypeInfo() noexcept {
return {};
}
template<typename T = void>
constexpr ox::Error setTypeInfo(const char*) noexcept {
constexpr Error setTypeInfo(CString) noexcept {
return {};
}
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 {};
}
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 {};
}
@@ -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<typename T>
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<T>) {
if (targetValid()) {
auto const&jv = value(key);
auto const &jv = value(key);
auto const rightType = sizeof(T) == 8 ?
(ox::is_signed_v<T> ? jv.isInt64() : jv.isUInt64()) :
(ox::is_signed_v<T> ? jv.isInt() : jv.isUInt());
(is_signed_v<T> ? jv.isInt64() : jv.isUInt64()) :
(is_signed_v<T> ? jv.isInt() : jv.isUInt());
if (jv.empty()) {
*val = 0;
} else if (rightType) {
if constexpr(ox::is_signed_v<T>) {
if constexpr(is_signed_v<T>) {
*val = static_cast<T>(jv.asInt64());
} else {
*val = static_cast<T>(jv.asUInt64());
}
} else {
err = ox::Error(1, "Type mismatch");
err = Error{1, "Type mismatch"};
}
}
} else if constexpr (isVector_v<T>) {
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<T>) {
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<typename U, bool force>
Error OrganicClawReader::field(const char *key, UnionView<U, force> val) noexcept {
ox::Error err{};
Error OrganicClawReader::field(CString const key, UnionView<U, force> 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<std::size_t L>
Error OrganicClawReader::field(const char *key, BasicString<L> *val) noexcept {
ox::Error err{};
template<size_t L>
Error OrganicClawReader::field(CString const key, BasicString<L> *val) noexcept {
Error err{};
if (targetValid()) {
const auto &jv = value(key);
auto const &jv = value(key);
if (jv.empty()) {
*val = BasicString<L>{};
} 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<std::size_t L>
Error OrganicClawReader::field(const char *key, IString<L> *val) noexcept {
ox::Error err{};
template<size_t L>
Error OrganicClawReader::field(CString const key, IString<L> *val) noexcept {
Error err{};
if (targetValid()) {
const auto &jv = value(key);
auto const &jv = value(key);
if (jv.empty()) {
*val = IString<L>{};
} 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<L> *val) noexcept {
// array handler
template<typename T>
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<typename T>
Error OrganicClawReader::field(const char *key, HashMap<String, T> *val) noexcept {
const auto &srcVal = value(key);
Error OrganicClawReader::field(CString const key, HashMap<String, T> *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<T> readOC(BufferView buff) noexcept {
}
template<typename T>
Result<T> readOC(ox::StringView json) noexcept {
return readOC<T>(ox::BufferView{json.data(), json.size()});
Result<T> readOC(StringViewCR json) noexcept {
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 {
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<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();
if (targetValid() && uuidStr.size()) {
value(key) = uuidStr.c_str();

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

@@ -28,20 +28,20 @@ namespace ox {
class OrganicClawWriter {
friend Result<ox::Buffer> writeOC(const auto &val) noexcept;
friend Result<ox::String> writeOCString(const auto &val) noexcept;
friend Result<Buffer> writeOC(const auto &val) noexcept;
friend Result<String> 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<U, force> val) noexcept;
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()) {
const auto &keys = val->keys();
OrganicClawWriter w;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
for (std::size_t i = 0; i < keys.size(); ++i) {
ModelHandlerInterface<OrganicClawWriter, OpType::Write> 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<std::size_t L>
Error field(char const*key, IString<L> const*val) noexcept {
template<size_t L>
Error field(char const*key, IString<L> const *val) noexcept {
if (targetValid() && val->size()) {
value(key) = val->c_str();
}
@@ -145,8 +145,8 @@ class OrganicClawWriter {
return {};
}
template<std::size_t L>
Error field(char const*key, BasicString<L> const*val) noexcept {
template<size_t L>
Error field(char const*key, BasicString<L> 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<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>
Error field(const char*, const T *val) noexcept;
Error field(const char*, T const *val) noexcept;
template<typename T>
constexpr ox::Error setTypeInfo(
constexpr Error setTypeInfo(
const char* = T::TypeName,
int = T::TypeVersion) noexcept {
return {};
}
template<typename T>
constexpr ox::Error setTypeInfo(
constexpr Error setTypeInfo(
const char*,
int,
const Vector<String>&,
std::size_t) noexcept {
Vector<String> const&,
size_t) noexcept {
return {};
}
@@ -199,11 +199,11 @@ class OrganicClawWriter {
};
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) {
OrganicClawWriter w((Json::Value(Json::arrayValue)));
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
for (std::size_t i = 0; i < len; ++i) {
ModelHandlerInterface<OrganicClawWriter, OpType::Write> 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<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 (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<T>) {
value(key) = static_cast<ox::Int<8 * sizeof(*val)>>(*val);
if constexpr(is_signed_v<T>) {
value(key) = static_cast<Int<8 * sizeof(*val)>>(*val);
} 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>) {
return field(key, val->data(), val->size());
} else if (val && targetValid()) {
OrganicClawWriter w;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
ModelHandlerInterface<OrganicClawWriter, OpType::Write> 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<typename U, bool force>
Error OrganicClawWriter::field(const char *key, UnionView<U, force> val) noexcept {
if (targetValid()) {
OrganicClawWriter w(val.idx());
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
ModelHandlerInterface<OrganicClawWriter, OpType::Write> 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<U, force> val) noexcep
return {};
}
Result<ox::Buffer> writeOC(const auto &val) noexcept {
Result<Buffer> writeOC(auto const &val) noexcept {
OrganicClawWriter writer;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(&writer);
ModelHandlerInterface<OrganicClawWriter, OpType::Write> 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<Buffer> buff;
buff.value.resize(str.size() + 1);
OX_ALLOW_UNSAFE_BUFFERS_BEGIN
@@ -268,13 +268,13 @@ Result<ox::Buffer> writeOC(const auto &val) noexcept {
return buff;
}
Result<ox::String> writeOCString(const auto &val) noexcept {
Result<String> writeOCString(auto const &val) noexcept {
OrganicClawWriter writer;
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(&writer);
ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(writer);
OX_RETURN_ERROR(model(&handler, &val));
Json::StreamWriterBuilder const jsonBuilder;
const auto str = Json::writeString(jsonBuilder, writer.m_json);
Result<ox::String> buff;
auto const str = Json::writeString(jsonBuilder, writer.m_json);
Result<String> buff;
buff.value.resize(str.size());
OX_ALLOW_UNSAFE_BUFFERS_BEGIN
memcpy(buff.value.data(), str.data(), str.size() + 1);