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;
};
[[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>
[[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);
oxReturnError(header);
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]] 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;
@ -106,15 +106,15 @@ class FileStoreTemplate {
* @return 0 if read is a success
*/
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 *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);
@ -124,13 +124,13 @@ class FileStoreTemplate {
[[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;
[[nodiscard]] ox::Error compact();
Error compact();
private:
FileStoreData *fileStoreData() const;

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

@ -43,7 +43,7 @@ struct OX_PACKED DirectoryEntry {
public:
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;
auto d = data();
if (d.valid()) {
@ -99,23 +99,23 @@ class 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
*/
[[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>
[[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) {
case FileAddressType::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) {
case FileAddressType::Path:
return m_data.path;

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

@ -10,7 +10,7 @@
namespace ox {
[[nodiscard]] ox::ValErr<uint8_t*> FileSystem::read(FileAddress addr) {
ValErr<uint8_t*> FileSystem::read(FileAddress addr) {
switch (addr.type()) {
case FileAddressType::Inode:
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()) {
case FileAddressType::Inode:
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()) {
case FileAddressType::Inode:
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()) {
case FileAddressType::Inode:
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:
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.
* @param src the path to the file
* @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;
@ -72,7 +72,7 @@ class FileSystem {
[[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;
@ -107,39 +107,39 @@ class FileSystemTemplate: public FileSystem {
[[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>
[[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.
*/
[[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;
@ -149,19 +149,19 @@ class FileSystemTemplate: public FileSystem {
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;
private:
[[nodiscard]] ValErr<FileSystemData> fileSystemData() const noexcept;
ValErr<FileSystemData> fileSystemData() const noexcept;
/**
* 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>
[[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();
oxReturnError(fd.error);
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>
[[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);
if (!data.valid()) {
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);
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]);
if (bytes == 9) {
*bytesRead = bytes;
@ -144,7 +144,7 @@ template<typename I>
}
template<typename I>
[[nodiscard]] ValErr<I> decodeInteger(McInt m) noexcept {
ValErr<I> decodeInteger(McInt m) noexcept {
std::size_t 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:
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;

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);
}
[[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)) {
// read the length
if (m_buffIt >= m_buffLen) {

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

@ -39,49 +39,49 @@ class MetalClawReader {
~MetalClawReader() noexcept;
[[nodiscard]] Error field(const char*, int8_t *val);
[[nodiscard]] Error field(const char*, int16_t *val);
[[nodiscard]] Error field(const char*, int32_t *val);
[[nodiscard]] Error field(const char*, int64_t *val);
Error field(const char*, int8_t *val);
Error field(const char*, int16_t *val);
Error field(const char*, int32_t *val);
Error field(const char*, int64_t *val);
[[nodiscard]] Error field(const char*, uint8_t *val);
[[nodiscard]] Error field(const char*, uint16_t *val);
[[nodiscard]] Error field(const char*, uint32_t *val);
[[nodiscard]] Error field(const char*, uint64_t *val);
Error field(const char*, uint8_t *val);
Error field(const char*, uint16_t *val);
Error field(const char*, uint32_t *val);
Error field(const char*, uint64_t *val);
[[nodiscard]] Error field(const char*, bool *val);
Error field(const char*, bool *val);
// array handler
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
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
template<typename T, typename Handler>
[[nodiscard]] Error field(const char*, Handler handler);
Error field(const char*, Handler handler);
template<typename T>
[[nodiscard]] Error field(const char*, ox::Vector<T> *val);
Error field(const char*, ox::Vector<T> *val);
template<typename T>
[[nodiscard]] Error field(const char*, T *val);
Error field(const char*, T *val);
template<typename U>
[[nodiscard]] Error field(const char*, UnionView<U> val);
Error field(const char*, UnionView<U> val);
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.
* @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.
@ -114,7 +114,7 @@ class MetalClawReader {
private:
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;
[[nodiscard]] Error field(const char*, int8_t *val) noexcept;
[[nodiscard]] Error field(const char*, int16_t *val) noexcept;
[[nodiscard]] Error field(const char*, int32_t *val) noexcept;
[[nodiscard]] Error field(const char*, int64_t *val) noexcept;
Error field(const char*, int8_t *val) noexcept;
Error field(const char*, int16_t *val) noexcept;
Error field(const char*, int32_t *val) noexcept;
Error field(const char*, int64_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint8_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint16_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint32_t *val) noexcept;
[[nodiscard]] Error field(const char*, uint64_t *val) noexcept;
Error field(const char*, uint8_t *val) noexcept;
Error field(const char*, uint16_t *val) noexcept;
Error field(const char*, uint32_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>
[[nodiscard]] Error field(const char*, T *val, std::size_t len);
Error field(const char*, T *val, std::size_t len);
template<typename T>
[[nodiscard]] Error field(const char*, Vector<T> *val);
Error field(const char*, Vector<T> *val);
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>
[[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>
[[nodiscard]] Error field(const char*, T *val);
Error field(const char*, T *val);
template<typename U>
[[nodiscard]] Error field(const char*, UnionView<U> val);
Error field(const char*, UnionView<U> val);
template<typename T = std::nullptr_t>
void setTypeInfo(const char *name = T::TypeName, int fields = T::Fields);
@ -84,7 +84,7 @@ class MetalClawWriter {
private:
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>
[[nodiscard]] Error MetalClawWriter::field(const char*, HashMap<String, T> *val) {
Error MetalClawWriter::field(const char*, HashMap<String, T> *val) {
auto &keys = val->keys();
auto len = keys.size();
bool fieldSet = false;

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

@ -60,12 +60,12 @@ class TypeDescWriter {
}
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);
}
template<typename T>
[[nodiscard]] constexpr ox::Error field(const char*, T) noexcept {
constexpr Error field(const char*, T) noexcept {
return OxError(0);
}
@ -85,13 +85,13 @@ class TypeDescWriter {
~TypeDescWriter();
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>
[[nodiscard]] ox::Error field(const char *name, T val);
Error field(const char *name, T val);
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>
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>
[[nodiscard]] ValErr<DescriptorType*> buildTypeDef(T *val) {
ValErr<DescriptorType*> buildTypeDef(T *val) {
TypeDescWriter writer;
Error err = model(&writer, val);
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
template<typename T, typename O>
[[nodiscard]] ox::Error modelRead(T*, O*) {
Error modelRead(T*, O*) {
return OxError(1, "Model: modelRead not implemented");
}
template<typename T, typename O>
[[nodiscard]] ox::Error modelWrite(T*, O*) {
Error modelWrite(T*, O*) {
return OxError(1, "Model: modelWrite not implemented");
}
template<typename T, typename O>
[[nodiscard]] ox::Error modelWriteDefinition(T*, O*) {
Error modelWriteDefinition(T*, O*) {
return OxError(1, "Model: modelWriteDefinition not implemented");
}
template<typename T, typename O>
[[nodiscard]] ox::Error model(T *io, O *obj) {
Error model(T *io, O *obj) {
ox::Error err;
if constexpr(ox_strcmp(T::opType(), ox::OpType::Read) == 0) {
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]] ox::Error read(const DescriptorField&, Reader *rdr);
Error read(const DescriptorField&, Reader *rdr);
protected:
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;
}
[[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);
if (jv.empty()) {
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);
[[nodiscard]] Error field(const char *key, int8_t *val);
[[nodiscard]] Error field(const char *key, int16_t *val);
[[nodiscard]] Error field(const char *key, int32_t *val);
[[nodiscard]] Error field(const char *key, int64_t *val);
Error field(const char *key, int8_t *val);
Error field(const char *key, int16_t *val);
Error field(const char *key, int32_t *val);
Error field(const char *key, int64_t *val);
[[nodiscard]] Error field(const char *key, uint8_t *val);
[[nodiscard]] Error field(const char *key, uint16_t *val);
[[nodiscard]] Error field(const char *key, uint32_t *val);
[[nodiscard]] Error field(const char *key, uint64_t *val);
Error field(const char *key, uint8_t *val);
Error field(const char *key, uint16_t *val);
Error field(const char *key, uint32_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
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>
[[nodiscard]] Error field(const char *key, Vector<T> *val);
Error field(const char *key, Vector<T> *val);
template<typename T>
[[nodiscard]] Error field(const char*, HashMap<String, T> *val);
Error field(const char*, HashMap<String, T> *val);
template<typename T>
[[nodiscard]] Error field(const char *key, T *val);
Error field(const char *key, T *val);
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>
[[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.
* @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.
@ -163,7 +163,7 @@ Error OrganicClawReader::field(const char *key, ox::Vector<T> *val) {
}
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);
auto keys = srcVal.getMemberNames();
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);
[[nodiscard]] Error field(const char*, int8_t *val);
[[nodiscard]] Error field(const char*, int16_t *val);
[[nodiscard]] Error field(const char*, int32_t *val);
[[nodiscard]] Error field(const char*, int64_t *val);
Error field(const char*, int8_t *val);
Error field(const char*, int16_t *val);
Error field(const char*, int32_t *val);
Error field(const char*, int64_t *val);
[[nodiscard]] Error field(const char*, uint8_t *val);
[[nodiscard]] Error field(const char*, uint16_t *val);
[[nodiscard]] Error field(const char*, uint32_t *val);
[[nodiscard]] Error field(const char*, uint64_t *val);
Error field(const char*, uint8_t *val);
Error field(const char*, uint16_t *val);
Error field(const char*, uint32_t *val);
Error field(const char*, uint64_t *val);
[[nodiscard]] Error field(const char*, bool *val);
Error field(const char*, bool *val);
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>
[[nodiscard]] Error field(const char*, UnionView<U> val);
Error field(const char*, UnionView<U> val);
template<typename T>
[[nodiscard]] Error field(const char*, ox::Vector<T> *val);
Error field(const char*, ox::Vector<T> *val);
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>
[[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>
[[nodiscard]] Error field(const char*, T *val);
Error field(const char*, T *val);
template<typename T = void>
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>
[[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()) {
auto &keys = val->keys();
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]] ox::Error free(ItemPtr item);
Error free(ItemPtr item);
[[nodiscard]] bool valid(size_t maxSize);
/**
* Set size, capacity.
*/
[[nodiscard]] ox::Error setSize(size_t size);
Error setSize(size_t size);
/**
* Get size, capacity.
@ -157,7 +157,7 @@ class OX_PACKED NodeBuffer {
static size_t spaceNeeded(size_t size);
template<typename F>
[[nodiscard]] ox::Error compact(F cb = [](uint64_t, ItemPtr) {});
Error compact(F cb = [](uint64_t, ItemPtr) {});
void truncate();

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

@ -83,7 +83,7 @@ struct [[nodiscard]] ValErr {
return error == 0;
}
[[nodiscard]] constexpr ox::Error get(T *val) noexcept {
constexpr Error get(T *val) noexcept {
*val = value;
return error;
}
@ -92,12 +92,12 @@ struct [[nodiscard]] ValErr {
namespace error {
[[nodiscard]] constexpr ox::Error toError(ox::Error e) noexcept {
constexpr Error toError(ox::Error e) noexcept {
return e;
}
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;
}