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

[ox] Remove now superfluous [[nodiscards]] from ox::Error functions

Browse Source
This commit is contained in:
Gary Talent 2020-10-15 23:32:36 -05:00
parent ec359a805e
commit 75814a2896
19 changed files with 168 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -27,14 +27,14 @@ struct ClawHeader {
std::size_t dataSize = 0; std::size_t dataSize = 0;
}; };
[[nodiscard]] ValErr<ClawHeader> readHeader(const char *buff, std::size_t buffLen) noexcept; ValErr<ClawHeader> readHeader(const char *buff, std::size_t buffLen) noexcept;
} }
[[nodiscard]] ValErr<Vector<char>> stripClawHeader(const char *buff, std::size_t buffLen) noexcept; ValErr<Vector<char>> stripClawHeader(const char *buff, std::size_t buffLen) noexcept;
template<typename T> template<typename T>
[[nodiscard]] Error readClaw(char *buff, std::size_t buffLen, T *val) { Error readClaw(char *buff, std::size_t buffLen, T *val) {
auto header = detail::readHeader(buff, buffLen); auto header = detail::readHeader(buff, buffLen);
oxReturnError(header); oxReturnError(header);
switch (header.value.fmt) { switch (header.value.fmt) {

28
deps/ox/src/ox/fs/filestore/filestoretemplate.hpp vendored
View File

@ -79,19 +79,19 @@ class FileStoreTemplate {
[[nodiscard]] static Error format(void *buffer, size_t bufferSize); [[nodiscard]] static Error format(void *buffer, size_t bufferSize);
[[nodiscard]] Error setSize(InodeId_t buffSize); Error setSize(InodeId_t buffSize);
[[nodiscard]] Error incLinks(InodeId_t id); Error incLinks(InodeId_t id);
[[nodiscard]] Error decLinks(InodeId_t id); Error decLinks(InodeId_t id);
[[nodiscard]] Error write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType = 0); Error write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType = 0);
[[nodiscard]] Error remove(InodeId_t id); Error remove(InodeId_t id);
[[nodiscard]] Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr) const; Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr) const;
[[nodiscard]] Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) const; Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) const;
const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id) const; const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id) const;
@ -106,15 +106,15 @@ class FileStoreTemplate {
* @return 0 if read is a success * @return 0 if read is a success
*/ */
template<typename T> template<typename T>
[[nodiscard]] ox::Error read(InodeId_t id, FsSize_t readStart, Error read(InodeId_t id, FsSize_t readStart,
FsSize_t readSize, T *data, FsSize_t readSize, T *data,
FsSize_t *size) const; FsSize_t *size) const;
[[nodiscard]] ValErr<StatInfo> stat(InodeId_t id); ValErr<StatInfo> stat(InodeId_t id);
[[nodiscard]] ox::Error resize(); Error resize();
[[nodiscard]] ox::Error resize(std::size_t size, void *newBuff = nullptr); Error resize(std::size_t size, void *newBuff = nullptr);
[[nodiscard]] InodeId_t spaceNeeded(FsSize_t size); [[nodiscard]] InodeId_t spaceNeeded(FsSize_t size);
@ -124,13 +124,13 @@ class FileStoreTemplate {
[[nodiscard]] char *buff(); [[nodiscard]] char *buff();
[[nodiscard]] Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)); Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t));
[[nodiscard]] ValErr<InodeId_t> generateInodeId(); ValErr<InodeId_t> generateInodeId();
bool valid() const; bool valid() const;
[[nodiscard]] ox::Error compact(); Error compact();
private: private:
FileStoreData *fileStoreData() const; FileStoreData *fileStoreData() const;

16
deps/ox/src/ox/fs/filesystem/directory.hpp vendored
View File

@ -43,7 +43,7 @@ struct OX_PACKED DirectoryEntry {
public: public:
DirectoryEntry() = default; DirectoryEntry() = default;
[[nodiscard]] ox::Error init(InodeId_t inode, const char *name, InodeId_t bufferSize) { Error init(InodeId_t inode, const char *name, InodeId_t bufferSize) {
m_bufferSize = bufferSize; m_bufferSize = bufferSize;
auto d = data(); auto d = data();
if (d.valid()) { if (d.valid()) {
@ -99,23 +99,23 @@ class Directory {
/** /**
* Initializes Directory. * Initializes Directory.
*/ */
[[nodiscard]] ox::Error init() noexcept; Error init() noexcept;
[[nodiscard]] ox::Error mkdir(PathIterator path, bool parents, FileName *nameBuff = nullptr); Error mkdir(PathIterator path, bool parents, FileName *nameBuff = nullptr);
/** /**
* @param parents indicates the operation should create non-existent directories in the path, like mkdir -p * @param parents indicates the operation should create non-existent directories in the path, like mkdir -p
*/ */
[[nodiscard]] ox::Error write(PathIterator it, InodeId_t inode, FileName *nameBuff = nullptr) noexcept; Error write(PathIterator it, InodeId_t inode, FileName *nameBuff = nullptr) noexcept;
[[nodiscard]] ox::Error remove(PathIterator it, FileName *nameBuff = nullptr) noexcept; Error remove(PathIterator it, FileName *nameBuff = nullptr) noexcept;
template<typename F> template<typename F>
[[nodiscard]] ox::Error ls(F cb) noexcept; Error ls(F cb) noexcept;
[[nodiscard]] ValErr<typename FileStore::InodeId_t> findEntry(const FileName &name) const noexcept; ValErr<typename FileStore::InodeId_t> findEntry(const FileName &name) const noexcept;
[[nodiscard]] ValErr<typename FileStore::InodeId_t> find(PathIterator name, FileName *nameBuff = nullptr) const noexcept; ValErr<typename FileStore::InodeId_t> find(PathIterator name, FileName *nameBuff = nullptr) const noexcept;
}; };

4
deps/ox/src/ox/fs/filesystem/filelocation.hpp vendored
View File

@ -68,7 +68,7 @@ class FileAddress {
} }
} }
[[nodiscard]] constexpr ValErr<uint64_t> getInode() const noexcept { ValErr<uint64_t> getInode() const noexcept {
switch (m_type) { switch (m_type) {
case FileAddressType::Inode: case FileAddressType::Inode:
return m_data.inode; return m_data.inode;
@ -77,7 +77,7 @@ class FileAddress {
} }
} }
[[nodiscard]] constexpr ValErr<const char*> getPath() const noexcept { ValErr<const char*> getPath() const noexcept {
switch (m_type) { switch (m_type) {
case FileAddressType::Path: case FileAddressType::Path:
return m_data.path; return m_data.path;

8
deps/ox/src/ox/fs/filesystem/filesystem.cpp vendored
View File

@ -10,7 +10,7 @@
namespace ox { namespace ox {
[[nodiscard]] ox::ValErr<uint8_t*> FileSystem::read(FileAddress addr) { ValErr<uint8_t*> FileSystem::read(FileAddress addr) {
switch (addr.type()) { switch (addr.type()) {
case FileAddressType::Inode: case FileAddressType::Inode:
return read(addr.getInode().value); return read(addr.getInode().value);
@ -22,7 +22,7 @@ namespace ox {
} }
} }
[[nodiscard]] ox::Error FileSystem::read(FileAddress addr, void *buffer, std::size_t size) { Error FileSystem::read(FileAddress addr, void *buffer, std::size_t size) {
switch (addr.type()) { switch (addr.type()) {
case FileAddressType::Inode: case FileAddressType::Inode:
return read(addr.getInode().value, buffer, size); return read(addr.getInode().value, buffer, size);
@ -34,7 +34,7 @@ namespace ox {
} }
} }
[[nodiscard]] ox::Error FileSystem::read(FileAddress addr, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) { Error FileSystem::read(FileAddress addr, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) {
switch (addr.type()) { switch (addr.type()) {
case FileAddressType::Inode: case FileAddressType::Inode:
return read(addr.getInode().value, readStart, readSize, buffer, size); return read(addr.getInode().value, readStart, readSize, buffer, size);
@ -46,7 +46,7 @@ namespace ox {
} }
} }
[[nodiscard]] ox::Error FileSystem::remove(FileAddress addr, bool recursive) { Error FileSystem::remove(FileAddress addr, bool recursive) {
switch (addr.type()) { switch (addr.type()) {
case FileAddressType::Inode: case FileAddressType::Inode:
return remove(addr.getInode().value, recursive); return remove(addr.getInode().value, recursive);

82
deps/ox/src/ox/fs/filesystem/filesystem.hpp vendored
View File

@ -21,48 +21,48 @@ class FileSystem {
public: public:
virtual ~FileSystem() = default; virtual ~FileSystem() = default;
[[nodiscard]] virtual ox::Error mkdir(const char *path, bool recursive = false) = 0; virtual Error mkdir(const char *path, bool recursive = false) = 0;
/** /**
* Moves an entry from one directory to another. * Moves an entry from one directory to another.
* @param src the path to the file * @param src the path to the file
* @param dest the path of the destination directory * @param dest the path of the destination directory
*/ */
[[nodiscard]] virtual ox::Error move(const char *src, const char *dest) = 0; virtual Error move(const char *src, const char *dest) = 0;
[[nodiscard]] virtual ox::Error read(const char *path, void *buffer, std::size_t buffSize) = 0; virtual Error read(const char *path, void *buffer, std::size_t buffSize) = 0;
[[nodiscard]] virtual ox::ValErr<uint8_t*> read(const char *path) = 0; virtual ValErr<uint8_t*> read(const char *path) = 0;
[[nodiscard]] virtual ox::Error read(uint64_t inode, void *buffer, std::size_t size) = 0; virtual Error read(uint64_t inode, void *buffer, std::size_t size) = 0;
[[nodiscard]] virtual ox::Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) = 0; virtual Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) = 0;
[[nodiscard]] virtual ox::ValErr<uint8_t*> read(uint64_t inode) = 0; virtual ValErr<uint8_t*> read(uint64_t inode) = 0;
[[nodiscard]] ox::Error read(FileAddress addr, void *buffer, std::size_t size); Error read(FileAddress addr, void *buffer, std::size_t size);
[[nodiscard]] ox::Error read(FileAddress addr, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size); Error read(FileAddress addr, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size);
[[nodiscard]] ox::ValErr<uint8_t*> read(FileAddress addr); ValErr<uint8_t*> read(FileAddress addr);
[[nodiscard]] virtual ox::Error remove(const char *path, bool recursive = false) = 0; virtual Error remove(const char *path, bool recursive = false) = 0;
[[nodiscard]] ox::Error remove(FileAddress addr, bool recursive = false); Error remove(FileAddress addr, bool recursive = false);
[[nodiscard]] virtual ox::Error resize(uint64_t size, void *buffer = nullptr) = 0; virtual Error resize(uint64_t size, void *buffer = nullptr) = 0;
[[nodiscard]] virtual ox::Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) = 0; virtual Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) = 0;
[[nodiscard]] virtual ox::Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) = 0; virtual Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) = 0;
[[nodiscard]] ox::Error write(FileAddress addr, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile); Error write(FileAddress addr, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile);
[[nodiscard]] virtual ox::ValErr<FileStat> stat(uint64_t inode) = 0; virtual ValErr<FileStat> stat(uint64_t inode) = 0;
[[nodiscard]] virtual ox::ValErr<FileStat> stat(const char *path) = 0; virtual ValErr<FileStat> stat(const char *path) = 0;
[[nodiscard]] ox::ValErr<FileStat> stat(FileAddress addr); ValErr<FileStat> stat(FileAddress addr);
[[nodiscard]] virtual uint64_t spaceNeeded(uint64_t size) = 0; [[nodiscard]] virtual uint64_t spaceNeeded(uint64_t size) = 0;
@ -72,7 +72,7 @@ class FileSystem {
[[nodiscard]] virtual char *buff() = 0; [[nodiscard]] virtual char *buff() = 0;
[[nodiscard]] virtual ox::Error walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) = 0; virtual Error walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) = 0;
[[nodiscard]] virtual bool valid() const = 0; [[nodiscard]] virtual bool valid() const = 0;
@ -107,39 +107,39 @@ class FileSystemTemplate: public FileSystem {
[[nodiscard]] static ox::Error format(void *buff, uint64_t buffSize); [[nodiscard]] static ox::Error format(void *buff, uint64_t buffSize);
[[nodiscard]] ox::Error mkdir(const char *path, bool recursive = false) override; Error mkdir(const char *path, bool recursive = false) override;
[[nodiscard]] ox::Error move(const char *src, const char *dest) override; Error move(const char *src, const char *dest) override;
[[nodiscard]] ox::Error read(const char *path, void *buffer, std::size_t buffSize) override; Error read(const char *path, void *buffer, std::size_t buffSize) override;
[[nodiscard]] ox::ValErr<uint8_t*> read(const char*) override; ValErr<uint8_t*> read(const char*) override;
[[nodiscard]] ox::Error read(uint64_t inode, void *buffer, std::size_t size) override; Error read(uint64_t inode, void *buffer, std::size_t size) override;
[[nodiscard]] ox::Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override; Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
[[nodiscard]] ox::ValErr<uint8_t*> read(uint64_t) override; ValErr<uint8_t*> read(uint64_t) override;
template<typename F> template<typename F>
[[nodiscard]] ox::Error ls(const char *dir, F cb); Error ls(const char *dir, F cb);
[[nodiscard]] ox::Error remove(const char *path, bool recursive = false) override; Error remove(const char *path, bool recursive = false) override;
/** /**
* Resizes FileSystem to minimum possible size. * Resizes FileSystem to minimum possible size.
*/ */
[[nodiscard]] ox::Error resize(); Error resize();
[[nodiscard]] ox::Error resize(uint64_t size, void *buffer = nullptr) override; Error resize(uint64_t size, void *buffer = nullptr) override;
[[nodiscard]] ox::Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override; Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
[[nodiscard]] ox::Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override; Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
[[nodiscard]] ox::ValErr<FileStat> stat(uint64_t inode) override; ValErr<FileStat> stat(uint64_t inode) override;
[[nodiscard]] ox::ValErr<FileStat> stat(const char *path) override; ValErr<FileStat> stat(const char *path) override;
uint64_t spaceNeeded(uint64_t size) override; uint64_t spaceNeeded(uint64_t size) override;
@ -149,19 +149,19 @@ class FileSystemTemplate: public FileSystem {
char *buff() override; char *buff() override;
[[nodiscard]] ox::Error walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) override; Error walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) override;
bool valid() const override; bool valid() const override;
private: private:
[[nodiscard]] ValErr<FileSystemData> fileSystemData() const noexcept; ValErr<FileSystemData> fileSystemData() const noexcept;
/** /**
* Finds the inode ID at the given path. * Finds the inode ID at the given path.
*/ */
[[nodiscard]] ValErr<uint64_t> find(const char *path) const noexcept; ValErr<uint64_t> find(const char *path) const noexcept;
[[nodiscard]] ValErr<Directory> rootDir() const noexcept; ValErr<Directory> rootDir() const noexcept;
}; };
@ -236,7 +236,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::read(const char *path, void
} }
template<typename FileStore, typename Directory> template<typename FileStore, typename Directory>
[[nodiscard]] ox::ValErr<uint8_t*> FileSystemTemplate<FileStore, Directory>::read(const char *path) { ValErr<uint8_t*> FileSystemTemplate<FileStore, Directory>::read(const char *path) {
auto fd = fileSystemData(); auto fd = fileSystemData();
oxReturnError(fd.error); oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode); Directory rootDir(m_fs, fd.value.rootDirInode);
@ -256,7 +256,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, std::si
} }
template<typename FileStore, typename Directory> template<typename FileStore, typename Directory>
[[nodiscard]] ox::ValErr<uint8_t*> FileSystemTemplate<FileStore, Directory>::read(uint64_t inode) { ValErr<uint8_t*> FileSystemTemplate<FileStore, Directory>::read(uint64_t inode) {
auto data = m_fs.read(inode); auto data = m_fs.read(inode);
if (!data.valid()) { if (!data.valid()) {
return OxError(1); return OxError(1);

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

@ -114,7 +114,7 @@ static_assert(countBytes(0b01111111) == 8);
static_assert(countBytes(0b11111111) == 9); static_assert(countBytes(0b11111111) == 9);
template<typename I> template<typename I>
[[nodiscard]] constexpr ValErr<I> decodeInteger(uint8_t buff[9], std::size_t buffLen, std::size_t *bytesRead) noexcept { ValErr<I> decodeInteger(uint8_t buff[9], std::size_t buffLen, std::size_t *bytesRead) noexcept {
const auto bytes = countBytes(buff[0]); const auto bytes = countBytes(buff[0]);
if (bytes == 9) { if (bytes == 9) {
*bytesRead = bytes; *bytesRead = bytes;
@ -144,7 +144,7 @@ template<typename I>
} }
template<typename I> template<typename I>
[[nodiscard]] ValErr<I> decodeInteger(McInt m) noexcept { ValErr<I> decodeInteger(McInt m) noexcept {
std::size_t bytesRead; std::size_t bytesRead;
return decodeInteger<I>(m.data, 9, &bytesRead); return decodeInteger<I>(m.data, 9, &bytesRead);
} }

4
deps/ox/src/ox/mc/presenceindicator.hpp vendored
View File

@ -22,9 +22,9 @@ class FieldPresenceIndicator {
public: public:
FieldPresenceIndicator(uint8_t *mask, std::size_t maxLen); FieldPresenceIndicator(uint8_t *mask, std::size_t maxLen);
[[nodiscard]] ValErr<bool> get(std::size_t i) const; ValErr<bool> get(std::size_t i) const;
[[nodiscard]] Error set(std::size_t i, bool on); Error set(std::size_t i, bool on);
void setFields(int) noexcept; void setFields(int) noexcept;

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

@ -109,7 +109,7 @@ Error MetalClawReader::field(const char*, SerStr val) {
return OxError(0); return OxError(0);
} }
[[nodiscard]] ValErr<ArrayLength> MetalClawReader::arrayLength(const char*, bool pass) { ValErr<ArrayLength> MetalClawReader::arrayLength(const char*, bool pass) {
if ((m_unionIdx == -1 || m_unionIdx == m_field) && m_fieldPresence.get(m_field)) { if ((m_unionIdx == -1 || m_unionIdx == m_field) && m_fieldPresence.get(m_field)) {
// read the length // read the length
if (m_buffIt >= m_buffLen) { if (m_buffIt >= m_buffLen) {

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

@ -39,49 +39,49 @@ class MetalClawReader {
~MetalClawReader() noexcept; ~MetalClawReader() noexcept;
[[nodiscard]] Error field(const char*, int8_t *val); Error field(const char*, int8_t *val);
[[nodiscard]] Error field(const char*, int16_t *val); Error field(const char*, int16_t *val);
[[nodiscard]] Error field(const char*, int32_t *val); Error field(const char*, int32_t *val);
[[nodiscard]] Error field(const char*, int64_t *val); Error field(const char*, int64_t *val);
[[nodiscard]] Error field(const char*, uint8_t *val); Error field(const char*, uint8_t *val);
[[nodiscard]] Error field(const char*, uint16_t *val); Error field(const char*, uint16_t *val);
[[nodiscard]] Error field(const char*, uint32_t *val); Error field(const char*, uint32_t *val);
[[nodiscard]] Error field(const char*, uint64_t *val); Error field(const char*, uint64_t *val);
[[nodiscard]] Error field(const char*, bool *val); Error field(const char*, bool *val);
// array handler // array handler
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, T *val, std::size_t len); Error field(const char*, T *val, std::size_t len);
// map handler // map handler
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, HashMap<String, T> *val); Error field(const char*, HashMap<String, T> *val);
// array handler, with callback to allow handling individual elements // array handler, with callback to allow handling individual elements
template<typename T, typename Handler> template<typename T, typename Handler>
[[nodiscard]] Error field(const char*, Handler handler); Error field(const char*, Handler handler);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, ox::Vector<T> *val); Error field(const char*, ox::Vector<T> *val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, T *val); Error field(const char*, T *val);
template<typename U> template<typename U>
[[nodiscard]] Error field(const char*, UnionView<U> val); Error field(const char*, UnionView<U> val);
template<std::size_t L> template<std::size_t L>
[[nodiscard]] Error field(const char*, ox::BString<L> *val); Error field(const char*, ox::BString<L> *val);
[[nodiscard]] Error field(const char*, SerStr val); Error field(const char*, SerStr val);
/** /**
* Reads an array length from the current location in the buffer. * Reads an array length from the current location in the buffer.
* @param pass indicates that the parsing should iterate past the array length * @param pass indicates that the parsing should iterate past the array length
*/ */
[[nodiscard]] ValErr<ArrayLength> arrayLength(const char *name, bool pass = true); ValErr<ArrayLength> arrayLength(const char *name, bool pass = true);
/** /**
* Reads an string length from the current location in the buffer. * Reads an string length from the current location in the buffer.
@ -114,7 +114,7 @@ class MetalClawReader {
private: private:
template<typename I> template<typename I>
[[nodiscard]] Error readInteger(I *val); Error readInteger(I *val);
}; };

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

@ -41,37 +41,37 @@ class MetalClawWriter {
~MetalClawWriter() noexcept; ~MetalClawWriter() noexcept;
[[nodiscard]] Error field(const char*, int8_t *val) noexcept; Error field(const char*, int8_t *val) noexcept;
[[nodiscard]] Error field(const char*, int16_t *val) noexcept; Error field(const char*, int16_t *val) noexcept;
[[nodiscard]] Error field(const char*, int32_t *val) noexcept; Error field(const char*, int32_t *val) noexcept;
[[nodiscard]] Error field(const char*, int64_t *val) noexcept; Error field(const char*, int64_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint8_t *val) noexcept; Error field(const char*, uint8_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint16_t *val) noexcept; Error field(const char*, uint16_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint32_t *val) noexcept; Error field(const char*, uint32_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint64_t *val) noexcept; Error field(const char*, uint64_t *val) noexcept;
[[nodiscard]] Error field(const char*, bool *val) noexcept; Error field(const char*, bool *val) noexcept;
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, T *val, std::size_t len); Error field(const char*, T *val, std::size_t len);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, Vector<T> *val); Error field(const char*, Vector<T> *val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, HashMap<String, T> *val); Error field(const char*, HashMap<String, T> *val);
template<std::size_t L> template<std::size_t L>
[[nodiscard]] Error field(const char*, ox::BString<L> *val) noexcept; Error field(const char*, ox::BString<L> *val) noexcept;
[[nodiscard]] Error field(const char*, SerStr val) noexcept; Error field(const char*, SerStr val) noexcept;
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, T *val); Error field(const char*, T *val);
template<typename U> template<typename U>
[[nodiscard]] Error field(const char*, UnionView<U> val); Error field(const char*, UnionView<U> val);
template<typename T = std::nullptr_t> template<typename T = std::nullptr_t>
void setTypeInfo(const char *name = T::TypeName, int fields = T::Fields); void setTypeInfo(const char *name = T::TypeName, int fields = T::Fields);
@ -84,7 +84,7 @@ class MetalClawWriter {
private: private:
template<typename I> template<typename I>
[[nodiscard]] Error appendInteger(I val) noexcept; Error appendInteger(I val) noexcept;
}; };
@ -162,7 +162,7 @@ Error MetalClawWriter::field(const char*, Vector<T> *val) {
} }
template<typename T> template<typename T>
[[nodiscard]] Error MetalClawWriter::field(const char*, HashMap<String, T> *val) { Error MetalClawWriter::field(const char*, HashMap<String, T> *val) {
auto &keys = val->keys(); auto &keys = val->keys();
auto len = keys.size(); auto len = keys.size();
bool fieldSet = false; bool fieldSet = false;

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

@ -60,12 +60,12 @@ class TypeDescWriter {
} }
template<typename T> template<typename T>
[[nodiscard]] constexpr ox::Error field(const char*, T*, std::size_t) noexcept { constexpr Error field(const char*, T*, std::size_t) noexcept {
return OxError(0); return OxError(0);
} }
template<typename T> template<typename T>
[[nodiscard]] constexpr ox::Error field(const char*, T) noexcept { constexpr Error field(const char*, T) noexcept {
return OxError(0); return OxError(0);
} }
@ -85,13 +85,13 @@ class TypeDescWriter {
~TypeDescWriter(); ~TypeDescWriter();
template<typename T> template<typename T>
[[nodiscard]] ox::Error field(const char *name, T *val, std::size_t valLen); Error field(const char *name, T *val, std::size_t valLen);
template<typename T> template<typename T>
[[nodiscard]] ox::Error field(const char *name, T val); Error field(const char *name, T val);
template<typename T> template<typename T>
[[nodiscard]] ox::Error field(const char *name, T *val); Error field(const char *name, T *val);
template<typename T = std::nullptr_t> template<typename T = std::nullptr_t>
void setTypeInfo(const char *name = T::TypeName, int fields = T::Fields); void setTypeInfo(const char *name = T::TypeName, int fields = T::Fields);
@ -234,7 +234,7 @@ void TypeDescWriter::setTypeInfo(const char *name, int) {
} }
template<typename T> template<typename T>
[[nodiscard]] ValErr<DescriptorType*> buildTypeDef(T *val) { ValErr<DescriptorType*> buildTypeDef(T *val) {
TypeDescWriter writer; TypeDescWriter writer;
Error err = model(&writer, val); Error err = model(&writer, val);
return {writer.definition(), err}; return {writer.definition(), err};

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

@ -23,22 +23,22 @@ namespace OpType {
// empty default implementations of model functions // empty default implementations of model functions
template<typename T, typename O> template<typename T, typename O>
[[nodiscard]] ox::Error modelRead(T*, O*) { Error modelRead(T*, O*) {
return OxError(1, "Model: modelRead not implemented"); return OxError(1, "Model: modelRead not implemented");
} }
template<typename T, typename O> template<typename T, typename O>
[[nodiscard]] ox::Error modelWrite(T*, O*) { Error modelWrite(T*, O*) {
return OxError(1, "Model: modelWrite not implemented"); return OxError(1, "Model: modelWrite not implemented");
} }
template<typename T, typename O> template<typename T, typename O>
[[nodiscard]] ox::Error modelWriteDefinition(T*, O*) { Error modelWriteDefinition(T*, O*) {
return OxError(1, "Model: modelWriteDefinition not implemented"); return OxError(1, "Model: modelWriteDefinition not implemented");
} }
template<typename T, typename O> template<typename T, typename O>
[[nodiscard]] ox::Error model(T *io, O *obj) { Error model(T *io, O *obj) {
ox::Error err; ox::Error err;
if constexpr(ox_strcmp(T::opType(), ox::OpType::Read) == 0) { if constexpr(ox_strcmp(T::opType(), ox::OpType::Read) == 0) {
err = modelRead(io, obj); err = modelRead(io, obj);

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

@ -30,7 +30,7 @@ class DataWalker {
[[nodiscard]] const DescriptorType *type() const noexcept; [[nodiscard]] const DescriptorType *type() const noexcept;
[[nodiscard]] ox::Error read(const DescriptorField&, Reader *rdr); Error read(const DescriptorField&, Reader *rdr);
protected: protected:
void pushNamePath(FieldName fn); void pushNamePath(FieldName fn);

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

@ -208,7 +208,7 @@ Error OrganicClawReader::field(const char *key, SerStr val) {
return err; return err;
} }
[[nodiscard]] ValErr<std::size_t> OrganicClawReader::arrayLength(const char *key, bool) { ValErr<std::size_t> OrganicClawReader::arrayLength(const char *key, bool) {
const auto &jv = value(key); const auto &jv = value(key);
if (jv.empty()) { if (jv.empty()) {
return 0; return 0;

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

@ -35,44 +35,44 @@ class OrganicClawReader {
OrganicClawReader(const Json::Value &json, int unionIdx = -1); OrganicClawReader(const Json::Value &json, int unionIdx = -1);
[[nodiscard]] Error field(const char *key, int8_t *val); Error field(const char *key, int8_t *val);
[[nodiscard]] Error field(const char *key, int16_t *val); Error field(const char *key, int16_t *val);
[[nodiscard]] Error field(const char *key, int32_t *val); Error field(const char *key, int32_t *val);
[[nodiscard]] Error field(const char *key, int64_t *val); Error field(const char *key, int64_t *val);
[[nodiscard]] Error field(const char *key, uint8_t *val); Error field(const char *key, uint8_t *val);
[[nodiscard]] Error field(const char *key, uint16_t *val); Error field(const char *key, uint16_t *val);
[[nodiscard]] Error field(const char *key, uint32_t *val); Error field(const char *key, uint32_t *val);
[[nodiscard]] Error field(const char *key, uint64_t *val); Error field(const char *key, uint64_t *val);
[[nodiscard]] Error field(const char *key, bool *val); Error field(const char *key, bool *val);
// array handler // array handler
template<typename T> template<typename T>
[[nodiscard]] Error field(const char *key, T *val, std::size_t len); Error field(const char *key, T *val, std::size_t len);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char *key, Vector<T> *val); Error field(const char *key, Vector<T> *val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, HashMap<String, T> *val); Error field(const char*, HashMap<String, T> *val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char *key, T *val); Error field(const char *key, T *val);
template<typename U> template<typename U>
[[nodiscard]] Error field(const char *key, UnionView<U> val); Error field(const char *key, UnionView<U> val);
template<std::size_t L> template<std::size_t L>
[[nodiscard]] Error field(const char *key, ox::BString<L> *val); Error field(const char *key, ox::BString<L> *val);
[[nodiscard]] Error field(const char *key, SerStr val); Error field(const char *key, SerStr val);
/** /**
* Reads an array length from the current location in the buffer. * Reads an array length from the current location in the buffer.
* @param pass indicates that the parsing should iterate past the array length * @param pass indicates that the parsing should iterate past the array length
*/ */
[[nodiscard]] ValErr<std::size_t> arrayLength(const char *key, bool pass = true); ValErr<std::size_t> arrayLength(const char *key, bool pass = true);
/** /**
* Reads an string length from the current location in the buffer. * Reads an string length from the current location in the buffer.
@ -163,7 +163,7 @@ Error OrganicClawReader::field(const char *key, ox::Vector<T> *val) {
} }
template<typename T> template<typename T>
[[nodiscard]] Error OrganicClawReader::field(const char *key, HashMap<String, T> *val) { Error OrganicClawReader::field(const char *key, HashMap<String, T> *val) {
const auto &srcVal = value(key); const auto &srcVal = value(key);
auto keys = srcVal.getMemberNames(); auto keys = srcVal.getMemberNames();
auto srcSize = srcVal.size(); auto srcSize = srcVal.size();

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

@ -33,39 +33,39 @@ class OrganicClawWriter {
OrganicClawWriter(Json::Value json, int unionIdx = -1); OrganicClawWriter(Json::Value json, int unionIdx = -1);
[[nodiscard]] Error field(const char*, int8_t *val); Error field(const char*, int8_t *val);
[[nodiscard]] Error field(const char*, int16_t *val); Error field(const char*, int16_t *val);
[[nodiscard]] Error field(const char*, int32_t *val); Error field(const char*, int32_t *val);
[[nodiscard]] Error field(const char*, int64_t *val); Error field(const char*, int64_t *val);
[[nodiscard]] Error field(const char*, uint8_t *val); Error field(const char*, uint8_t *val);
[[nodiscard]] Error field(const char*, uint16_t *val); Error field(const char*, uint16_t *val);
[[nodiscard]] Error field(const char*, uint32_t *val); Error field(const char*, uint32_t *val);
[[nodiscard]] Error field(const char*, uint64_t *val); Error field(const char*, uint64_t *val);
[[nodiscard]] Error field(const char*, bool *val); Error field(const char*, bool *val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, T *val, std::size_t len); Error field(const char*, T *val, std::size_t len);
template<typename U> template<typename U>
[[nodiscard]] Error field(const char*, UnionView<U> val); Error field(const char*, UnionView<U> val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, ox::Vector<T> *val); Error field(const char*, ox::Vector<T> *val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, HashMap<String, T> *val); Error field(const char*, HashMap<String, T> *val);
template<std::size_t L> template<std::size_t L>
[[nodiscard]] Error field(const char*, ox::BString<L> *val); Error field(const char*, ox::BString<L> *val);
[[nodiscard]] Error field(const char*, ox::String val); Error field(const char*, ox::String val);
[[nodiscard]] Error field(const char*, SerStr val); Error field(const char*, SerStr val);
template<typename T> template<typename T>
[[nodiscard]] Error field(const char*, T *val); Error field(const char*, T *val);
template<typename T = void> template<typename T = void>
constexpr void setTypeInfo(const char* = T::TypeName, int = T::Fields) { constexpr void setTypeInfo(const char* = T::TypeName, int = T::Fields) {
@ -134,7 +134,7 @@ Error OrganicClawWriter::field(const char *key, ox::Vector<T> *val) {
} }
template<typename T> template<typename T>
[[nodiscard]] Error OrganicClawWriter::field(const char *key, ox::HashMap<String, T> *val) { Error OrganicClawWriter::field(const char *key, ox::HashMap<String, T> *val) {
if (targetValid()) { if (targetValid()) {
auto &keys = val->keys(); auto &keys = val->keys();
OrganicClawWriter w; OrganicClawWriter w;

6
deps/ox/src/ox/ptrarith/nodebuffer.hpp vendored
View File

@ -130,14 +130,14 @@ class OX_PACKED NodeBuffer {
[[nodiscard]] ItemPtr malloc(size_t size); [[nodiscard]] ItemPtr malloc(size_t size);
[[nodiscard]] ox::Error free(ItemPtr item); Error free(ItemPtr item);
[[nodiscard]] bool valid(size_t maxSize); [[nodiscard]] bool valid(size_t maxSize);
/** /**
* Set size, capacity. * Set size, capacity.
*/ */
[[nodiscard]] ox::Error setSize(size_t size); Error setSize(size_t size);
/** /**
* Get size, capacity. * Get size, capacity.
@ -157,7 +157,7 @@ class OX_PACKED NodeBuffer {
static size_t spaceNeeded(size_t size); static size_t spaceNeeded(size_t size);
template<typename F> template<typename F>
[[nodiscard]] ox::Error compact(F cb = [](uint64_t, ItemPtr) {}); Error compact(F cb = [](uint64_t, ItemPtr) {});
void truncate(); void truncate();

6
deps/ox/src/ox/std/error.hpp vendored
View File

@ -83,7 +83,7 @@ struct [[nodiscard]] ValErr {
return error == 0; return error == 0;
} }
[[nodiscard]] constexpr ox::Error get(T *val) noexcept { constexpr Error get(T *val) noexcept {
*val = value; *val = value;
return error; return error;
} }
@ -92,12 +92,12 @@ struct [[nodiscard]] ValErr {
namespace error { namespace error {
[[nodiscard]] constexpr ox::Error toError(ox::Error e) noexcept { constexpr Error toError(ox::Error e) noexcept {
return e; return e;
} }
template<typename T> template<typename T>
[[nodiscard]] constexpr ox::Error toError(const ox::ValErr<T> &ve) noexcept { constexpr Error toError(const ox::ValErr<T> &ve) noexcept {
return ve.error; return ve.error;
} }