diff --git a/deps/ox/src/ox/fs/filestore.hpp b/deps/ox/src/ox/fs/filestore.hpp
index f6fc5f2d..e843988a 100644
--- a/deps/ox/src/ox/fs/filestore.hpp
+++ b/deps/ox/src/ox/fs/filestore.hpp
@@ -709,7 +709,7 @@ int FileStore<Header>::read(Inode *inode, typename Header::FsSize_t readStart,
// do byte-by-byte copy to ensure alignment is right when copying to
// final destination
T val;
- for (size_t i = 0; i < sizeof(T); i++) {
+ for (std::size_t i = 0; i < sizeof(T); i++) {
((uint8_t*) (&val))[i] = *(it++);
}
*(data++) = val;
diff --git a/deps/ox/src/ox/fs/filestore/ptr.hpp b/deps/ox/src/ox/fs/filestore/ptr.hpp
index 7dbe3748..0169b6b7 100644
--- a/deps/ox/src/ox/fs/filestore/ptr.hpp
+++ b/deps/ox/src/ox/fs/filestore/ptr.hpp
@@ -38,16 +38,24 @@ class Ptr {
inline size_t end();
- inline T *get() const;
+ inline const T *get() const;
- inline T *operator->() const;
+ inline T *get();
- inline operator T*() const;
+ inline const T *operator->() const;
+
+ inline T *operator->();
+
+ inline operator const T*() const;
+
+ inline operator T*();
+
+ inline const T &operator*() const;
+
+ inline T &operator*();
inline operator size_t() const;
- inline T &operator*() const;
-
template<typename SubT>
inline Ptr<SubT, size_t, sizeof(T)> subPtr(size_t offset, size_t size);
@@ -95,24 +103,57 @@ inline size_t Ptr<T, size_t, minOffset>::end() {
}
template<typename T, typename size_t, size_t minOffset>
-inline T *Ptr<T, size_t, minOffset>::get() const {
+inline const T *Ptr<T, size_t, minOffset>::get() const {
oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::get())");
oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::get())");
return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
}
template<typename T, typename size_t, size_t minOffset>
-inline T *Ptr<T, size_t, minOffset>::operator->() const {
+inline T *Ptr<T, size_t, minOffset>::get() {
+ oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::get())");
+ oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::get())");
+ return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
+}
+
+template<typename T, typename size_t, size_t minOffset>
+inline const T *Ptr<T, size_t, minOffset>::operator->() const {
oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator->())");
oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator->())");
return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
}
template<typename T, typename size_t, size_t minOffset>
-inline Ptr<T, size_t, minOffset>::operator T*() const {
+inline T *Ptr<T, size_t, minOffset>::operator->() {
+ oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator->())");
+ oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator->())");
return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
}
+template<typename T, typename size_t, size_t minOffset>
+inline Ptr<T, size_t, minOffset>::operator const T*() const {
+ return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
+}
+
+template<typename T, typename size_t, size_t minOffset>
+inline Ptr<T, size_t, minOffset>::operator T*() {
+ return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
+}
+
+template<typename T, typename size_t, size_t minOffset>
+inline const T &Ptr<T, size_t, minOffset>::operator*() const {
+ oxAssert(m_validated, "Unvalidated pointer dereference. (ox::fs::Ptr::operator*())");
+ oxAssert(valid(), "Invalid pointer dereference. (ox::fs::Ptr::operator*())");
+ return *reinterpret_cast<T*>(this);
+}
+
+template<typename T, typename size_t, size_t minOffset>
+inline T &Ptr<T, size_t, minOffset>::operator*() {
+ oxAssert(m_validated, "Unvalidated pointer dereference. (ox::fs::Ptr::operator*())");
+ oxAssert(valid(), "Invalid pointer dereference. (ox::fs::Ptr::operator*())");
+ return *reinterpret_cast<T*>(this);
+}
+
template<typename T, typename size_t, size_t minOffset>
inline Ptr<T, size_t, minOffset>::operator size_t() const {
if (m_dataStart and m_itemOffset) {
@@ -121,13 +162,6 @@ inline Ptr<T, size_t, minOffset>::operator size_t() const {
return 0;
}
-template<typename T, typename size_t, size_t minOffset>
-inline T &Ptr<T, size_t, minOffset>::operator*() const {
- oxAssert(m_validated, "Unvalidated pointer dereference. (ox::fs::Ptr::operator*())");
- oxAssert(valid(), "Invalid pointer dereference. (ox::fs::Ptr::operator*())");
- return *reinterpret_cast<T*>(this);
-}
-
template<typename T, typename size_t, size_t minOffset>
template<typename SubT>
inline Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset, size_t size) {
diff --git a/deps/ox/src/ox/fs/filesystem/directory.hpp b/deps/ox/src/ox/fs/filesystem/directory.hpp
index 39b0c533..de5ed9ee 100644
--- a/deps/ox/src/ox/fs/filesystem/directory.hpp
+++ b/deps/ox/src/ox/fs/filesystem/directory.hpp
@@ -86,7 +86,7 @@ struct __attribute__((packed)) Directory {
uint64_t getFileInode(const char *name);
- int getChildrenInodes(InodeId_t *inodes, size_t inodesLen);
+ int getChildrenInodes(InodeId_t *inodes, std::size_t inodesLen);
int rmFile(const char *name);
@@ -123,7 +123,7 @@ uint64_t Directory<InodeId_t, FsSize_t>::getFileInode(const char *name) {
}
template<typename InodeId_t, typename FsSize_t>
-int Directory<InodeId_t, FsSize_t>::getChildrenInodes(InodeId_t *inodes, size_t inodesLen) {
+int Directory<InodeId_t, FsSize_t>::getChildrenInodes(InodeId_t *inodes, std::size_t inodesLen) {
if (inodesLen >= this->children) {
auto current = files();
if (current) {
@@ -205,4 +205,4 @@ int Directory<InodeId_t, FsSize_t>::ls(List *list) {
}
}
-}
\ No newline at end of file
+}
diff --git a/deps/ox/src/ox/fs/filesystem/filesystem.cpp b/deps/ox/src/ox/fs/filesystem/filesystem.cpp
index 7bfa672b..d6f6fed9 100644
--- a/deps/ox/src/ox/fs/filesystem/filesystem.cpp
+++ b/deps/ox/src/ox/fs/filesystem/filesystem.cpp
@@ -14,7 +14,7 @@ template class FileSystemTemplate<FileStore16, OxFS_16>;
template class FileSystemTemplate<FileStore32, OxFS_32>;
template class FileSystemTemplate<FileStore64, OxFS_64>;
-FileSystem *createFileSystem(uint8_t *buff, size_t buffSize, bool ownsBuff) {
+FileSystem *createFileSystem(uint8_t *buff, std::size_t buffSize, bool ownsBuff) {
auto version = ((FileStore16*) buff)->version();
auto type = ((FileStore16*) buff)->fsType();
FileSystem *fs = nullptr;
@@ -45,7 +45,7 @@ FileSystem *createFileSystem(uint8_t *buff, size_t buffSize, bool ownsBuff) {
return fs;
}
-FileSystem *expandCopy(FileSystem *fs, size_t size) {
+FileSystem *expandCopy(FileSystem *fs, std::size_t size) {
auto fsBuff = fs->buff();
FileSystem *retval = nullptr;
@@ -61,7 +61,7 @@ FileSystem *expandCopy(FileSystem *fs, size_t size) {
return retval;
}
-FileSystem *expandCopyCleanup(FileSystem *fs, size_t size) {
+FileSystem *expandCopyCleanup(FileSystem *fs, std::size_t size) {
auto out = expandCopy(fs, size);
if (!out) {
diff --git a/deps/ox/src/ox/fs/filesystem/filesystem.hpp b/deps/ox/src/ox/fs/filesystem/filesystem.hpp
index b604867b..85d35e6b 100644
--- a/deps/ox/src/ox/fs/filesystem/filesystem.hpp
+++ b/deps/ox/src/ox/fs/filesystem/filesystem.hpp
@@ -33,13 +33,13 @@ class FileSystem {
template<typename List>
int ls(const char *path, List *list);
- virtual int read(const char *path, void *buffer, size_t buffSize) = 0;
+ virtual int read(const char *path, void *buffer, std::size_t buffSize) = 0;
- virtual int read(uint64_t inode, void *buffer, size_t size) = 0;
+ virtual int read(uint64_t inode, void *buffer, std::size_t size) = 0;
- virtual int read(uint64_t inode, size_t readStart, size_t readSize, void *buffer, size_t *size) = 0;
+ virtual int read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) = 0;
- virtual uint8_t *read(uint64_t inode, size_t *size) = 0;
+ virtual uint8_t *read(uint64_t inode, std::size_t *size) = 0;
virtual int remove(uint64_t inode, bool recursive = false) = 0;
@@ -75,7 +75,7 @@ int FileSystem::ls(const char *path, List *list) {
int err = 0;
auto s = stat(path);
if (s.fileType == FileType_Directory) {
- uint8_t dirBuff[max(static_cast<size_t>(s.size), sizeof(Dir)) * 4];
+ uint8_t dirBuff[max(static_cast<std::size_t>(s.size), sizeof(Dir)) * 4];
auto dir = (Directory<uint64_t, uint64_t>*) dirBuff;
err |= readDirectory(path, dir);
if (!err) {
@@ -85,7 +85,7 @@ int FileSystem::ls(const char *path, List *list) {
return err;
}
-FileSystem *createFileSystem(uint8_t *buff, size_t buffSize, bool ownsBuff = false);
+FileSystem *createFileSystem(uint8_t *buff, std::size_t buffSize, bool ownsBuff = false);
/**
* Creates a larger version of the given FileSystem.
@@ -96,6 +96,6 @@ FileSystem *expandCopy(FileSystem *src);
* Calls expandCopy and deletes the original FileSystem and buff a resize was
* performed.
*/
-FileSystem *expandCopyCleanup(FileSystem *fs, size_t size);
+FileSystem *expandCopyCleanup(FileSystem *fs, std::size_t size);
}
diff --git a/deps/ox/src/ox/fs/filesystem/filesystemtemplate.hpp b/deps/ox/src/ox/fs/filesystem/filesystemtemplate.hpp
index f7b4bec9..fb6af523 100644
--- a/deps/ox/src/ox/fs/filesystem/filesystemtemplate.hpp
+++ b/deps/ox/src/ox/fs/filesystem/filesystemtemplate.hpp
@@ -33,13 +33,13 @@ class FileSystemTemplate: public FileSystem {
int mkdir(const char *path, bool recursive = false) override;
- int read(const char *path, void *buffer, size_t buffSize) override;
+ int read(const char *path, void *buffer, std::size_t buffSize) override;
- int read(uint64_t inode, void *buffer, size_t buffSize) override;
+ int read(uint64_t inode, void *buffer, std::size_t buffSize) override;
- int read(uint64_t inode, size_t readStart, size_t readSize, void *buffer, size_t *size) override;
+ int read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
- uint8_t *read(uint64_t inode, size_t *size) override;
+ uint8_t *read(uint64_t inode, std::size_t *size) override;
void resize(uint64_t size = 0) override;
@@ -201,7 +201,7 @@ FileStat FileSystemTemplate<FileStore, FS_TYPE>::stat(uint64_t inode) {
#pragma warning(disable:4244)
#endif
template<typename FileStore, FsType FS_TYPE>
-int FileSystemTemplate<FileStore, FS_TYPE>::read(const char *path, void *buffer, size_t buffSize) {
+int FileSystemTemplate<FileStore, FS_TYPE>::read(const char *path, void *buffer, std::size_t buffSize) {
int retval = -1;
// find the inode for the given path
@@ -222,7 +222,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::read(const char *path, void *buffer,
#pragma warning(disable:4244)
#endif
template<typename FileStore, FsType FS_TYPE>
-int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, void *buffer, size_t buffSize) {
+int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, void *buffer, std::size_t buffSize) {
auto stat = m_store->stat(inode);
if (stat.size <= buffSize) {
return m_store->read(inode, buffer, nullptr);
@@ -237,9 +237,9 @@ int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, void *buffer, s
#pragma warning(disable:4244)
#endif
template<typename FileStore, FsType FS_TYPE>
-int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, size_t readStart,
- size_t readSize, void *buffer,
- size_t *size) {
+int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, std::size_t readStart,
+ std::size_t readSize, void *buffer,
+ std::size_t *size) {
if (size) {
auto stat = m_store->stat(inode);
*size = stat.size;
@@ -254,7 +254,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, size_t readStar
#pragma warning(disable:4244)
#endif
template<typename FileStore, FsType FS_TYPE>
-uint8_t *FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, size_t *size) {
+uint8_t *FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, std::size_t *size) {
auto s = m_store->stat(inode);
auto buff = new uint8_t[s.size];
if (size) {
@@ -329,7 +329,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::remove(uint64_t inode, bool recursiv
template<typename FileStore, FsType FS_TYPE>
int FileSystemTemplate<FileStore, FS_TYPE>::write(const char *path, void *buffer, uint64_t size, uint8_t fileType) {
int err = 0;
- size_t pathLen = ox_strlen(path);
+ std::size_t pathLen = ox_strlen(path);
char dirPath[pathLen];
char fileName[pathLen];
PathIterator pathReader(path, pathLen);
@@ -484,7 +484,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::insertDirectoryEntry(const char *dir
auto s = stat(dirPath);
if (s.inode) {
auto spaceNeeded = DirectoryEntry<typename FileStore::InodeId_t>::spaceNeeded(fileName);
- size_t dirBuffSize = s.size + spaceNeeded;
+ std::size_t dirBuffSize = s.size + spaceNeeded;
uint8_t dirBuff[dirBuffSize];
int err = read(s.inode, dirBuff, dirBuffSize);
@@ -515,7 +515,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::move(const char *src, const char *de
if (inode && !stat(dest).inode) {
int err = 0;
- size_t srcLen = ox_strlen(src);
+ std::size_t srcLen = ox_strlen(src);
char srcDirPath[srcLen];
char srcFileName[srcLen];
PathIterator srcPathReader(src, srcLen);
@@ -525,7 +525,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::move(const char *src, const char *de
return err;
}
- size_t destLen = ox_strlen(dest);
+ std::size_t destLen = ox_strlen(dest);
char destDirPath[destLen];
char destFileName[destLen];
PathIterator destPathReader(dest, destLen);
@@ -554,7 +554,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::move(const char *src, const char *de
template<typename FileStore, FsType FS_TYPE>
int FileSystemTemplate<FileStore, FS_TYPE>::rmDirectoryEntry(const char *path) {
int err = 0;
- size_t pathLen = ox_strlen(path);
+ std::size_t pathLen = ox_strlen(path);
char dirPath[pathLen];
char fileName[pathLen];
PathIterator pathReader(path, pathLen);
@@ -592,7 +592,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::readDirectory(const char *path, Dire
typedef Directory<typename FileStore::InodeId_t, typename FileStore::FsSize_t> Dir;
int err = 0;
auto dirStat = stat(path);
- auto dirBuffLen = ox::max(static_cast<size_t>(dirStat.size), sizeof(Dir));
+ auto dirBuffLen = ox::max(static_cast<std::size_t>(dirStat.size), sizeof(Dir));
uint8_t dirBuff[dirBuffLen];
auto dir = (Dir*) dirBuff;
diff --git a/deps/ox/src/ox/fs/filesystem/pathiterator.cpp b/deps/ox/src/ox/fs/filesystem/pathiterator.cpp
index 438ee10d..06ce55fb 100644
--- a/deps/ox/src/ox/fs/filesystem/pathiterator.cpp
+++ b/deps/ox/src/ox/fs/filesystem/pathiterator.cpp
@@ -12,7 +12,7 @@
namespace ox {
-PathIterator::PathIterator(const char *path, size_t maxSize) {
+PathIterator::PathIterator(const char *path, std::size_t maxSize) {
m_path = path;
m_maxSize = maxSize;
}
@@ -20,9 +20,9 @@ PathIterator::PathIterator(const char *path, size_t maxSize) {
/**
* @return 0 if no error
*/
-int PathIterator::dirPath(char *out, size_t outSize) {
+int PathIterator::dirPath(char *out, std::size_t outSize) {
int idx = ox_lastIndexOf(m_path, '/', m_maxSize);
- size_t size = idx + 1;
+ std::size_t size = idx + 1;
if (idx >= 0 && size < outSize) {
ox_memcpy(out, m_path, size);
out[size] = 0;
@@ -35,11 +35,11 @@ int PathIterator::dirPath(char *out, size_t outSize) {
/**
* @return 0 if no error
*/
-int PathIterator::fileName(char *out, size_t outSize) {
+int PathIterator::fileName(char *out, std::size_t outSize) {
auto idx = ox_lastIndexOf(m_path, '/', m_maxSize);
if (idx >= 0) {
idx++; // pass up the preceding /
- size_t fileNameSize = ox_strlen(&m_path[idx]);
+ std::size_t fileNameSize = ox_strlen(&m_path[idx]);
if (fileNameSize < outSize) {
ox_memcpy(out, &m_path[idx], fileNameSize);
out[fileNameSize] = 0;
@@ -53,22 +53,22 @@ int PathIterator::fileName(char *out, size_t outSize) {
}
// Gets the next item in the path
-int PathIterator::next(char *pathOut, size_t pathOutSize) {
- size_t size = 0;
+int PathIterator::next(char *pathOut, std::size_t pathOutSize) {
+ std::size_t size = 0;
int retval = 1;
if (m_iterator < m_maxSize && ox_strlen(&m_path[m_iterator])) {
retval = 0;
if (m_path[m_iterator] == '/') {
m_iterator++;
}
- size_t start = m_iterator;
+ std::size_t start = m_iterator;
// end is at the next /
const char *substr = ox_strchr(&m_path[start], '/', m_maxSize - start);
// correct end if it is invalid, which happens if there is no next /
if (!substr) {
substr = ox_strchr(&m_path[start], 0, m_maxSize - start);
}
- size_t end = substr - m_path;
+ std::size_t end = substr - m_path;
size = end - start;
// cannot fit the output in the output parameter
if (size >= pathOutSize) {
@@ -86,9 +86,9 @@ int PathIterator::next(char *pathOut, size_t pathOutSize) {
}
bool PathIterator::hasNext() {
- size_t size = 0;
+ std::size_t size = 0;
if (m_iterator < m_maxSize && ox_strlen(&m_path[m_iterator])) {
- size_t start = m_iterator;
+ std::size_t start = m_iterator;
if (m_path[start] == '/') {
start++;
}
@@ -98,7 +98,7 @@ bool PathIterator::hasNext() {
if (!substr) {
substr = ox_strchr(&m_path[start], 0, m_maxSize - start);
}
- size_t end = substr - m_path;
+ std::size_t end = substr - m_path;
size = end - start;
}
return size > 0;
diff --git a/deps/ox/src/ox/fs/filesystem/pathiterator.hpp b/deps/ox/src/ox/fs/filesystem/pathiterator.hpp
index 2ea8ecd8..f64d3717 100644
--- a/deps/ox/src/ox/fs/filesystem/pathiterator.hpp
+++ b/deps/ox/src/ox/fs/filesystem/pathiterator.hpp
@@ -15,26 +15,26 @@ namespace ox {
class PathIterator {
private:
const char *m_path = nullptr;
- size_t m_iterator = 0;
- size_t m_maxSize = 0;
+ std::size_t m_iterator = 0;
+ std::size_t m_maxSize = 0;
public:
- PathIterator(const char *path, size_t maxSize);
+ PathIterator(const char *path, std::size_t maxSize);
/**
* @return 0 if no error
*/
- int dirPath(char *pathOut, size_t pathOutSize);
+ int dirPath(char *pathOut, std::size_t pathOutSize);
/**
* @return 0 if no error
*/
- int fileName(char *out, size_t outSize);
+ int fileName(char *out, std::size_t outSize);
/**
* @return 0 if no error
*/
- int next(char *pathOut, size_t pathOutSize);
+ int next(char *pathOut, std::size_t pathOutSize);
bool hasNext();
};
diff --git a/deps/ox/src/ox/mc/presencemask.cpp b/deps/ox/src/ox/mc/presencemask.cpp
index b6aef4e2..006a21b2 100644
--- a/deps/ox/src/ox/mc/presencemask.cpp
+++ b/deps/ox/src/ox/mc/presencemask.cpp
@@ -12,7 +12,7 @@
namespace ox {
-FieldPresenseMask::FieldPresenseMask(uint8_t *mask, size_t maxLen) {
+FieldPresenseMask::FieldPresenseMask(uint8_t *mask, std::size_t maxLen) {
m_mask = mask;
m_maxLen = maxLen;
}
diff --git a/deps/ox/src/ox/mc/presencemask.hpp b/deps/ox/src/ox/mc/presencemask.hpp
index 5e8e1db0..3da1627e 100644
--- a/deps/ox/src/ox/mc/presencemask.hpp
+++ b/deps/ox/src/ox/mc/presencemask.hpp
@@ -18,7 +18,7 @@ class FieldPresenseMask {
int m_maxLen = 0;
public:
- FieldPresenseMask(uint8_t *mask, size_t maxLen);
+ FieldPresenseMask(uint8_t *mask, std::size_t maxLen);
bool get(int i);
diff --git a/deps/ox/src/ox/mc/read.cpp b/deps/ox/src/ox/mc/read.cpp
index 230a47a1..4336362a 100644
--- a/deps/ox/src/ox/mc/read.cpp
+++ b/deps/ox/src/ox/mc/read.cpp
@@ -12,7 +12,7 @@
namespace ox {
-MetalClawReader::MetalClawReader(uint8_t *buff, size_t buffLen): m_fieldPresence(buff, buffLen) {
+MetalClawReader::MetalClawReader(uint8_t *buff, std::size_t buffLen): m_fieldPresence(buff, buffLen) {
m_buff = buff;
m_buffLen = buffLen;
}
@@ -55,8 +55,8 @@ int MetalClawReader::op(const char*, bool *val) {
return 0;
}
-size_t MetalClawReader::arrayLength(const char*) {
- size_t len = 0;
+std::size_t MetalClawReader::arrayLength(const char*) {
+ std::size_t len = 0;
if (m_fieldPresence.get(m_field)) {
// read the length
if (m_buffIt + sizeof(ArrayLength) < m_buffLen) {
@@ -66,8 +66,8 @@ size_t MetalClawReader::arrayLength(const char*) {
return len;
}
-size_t MetalClawReader::stringLength(const char*) {
- size_t len = 0;
+std::size_t MetalClawReader::stringLength(const char*) {
+ std::size_t len = 0;
if (m_fieldPresence.get(m_field)) {
// read the length
if (m_buffIt + sizeof(StringLength) < m_buffLen) {
diff --git a/deps/ox/src/ox/mc/read.hpp b/deps/ox/src/ox/mc/read.hpp
index 8764b40c..e970e661 100644
--- a/deps/ox/src/ox/mc/read.hpp
+++ b/deps/ox/src/ox/mc/read.hpp
@@ -25,12 +25,12 @@ class MetalClawReader {
FieldPresenseMask m_fieldPresence;
int m_fields = 0;
int m_field = 0;
- size_t m_buffIt = 0;
- size_t m_buffLen = 0;
+ std::size_t m_buffIt = 0;
+ std::size_t m_buffLen = 0;
uint8_t *m_buff = nullptr;
public:
- MetalClawReader(uint8_t *buff, size_t buffLen);
+ MetalClawReader(uint8_t *buff, std::size_t buffLen);
int op(const char*, int8_t *val);
int op(const char*, int16_t *val);
@@ -45,18 +45,18 @@ class MetalClawReader {
int op(const char*, bool *val);
template<typename T>
- int op(const char*, T *val, size_t len);
+ int op(const char*, T *val, std::size_t len);
template<typename T>
int op(const char*, T *val);
- template<size_t L>
+ template<std::size_t L>
int op(const char*, ox::BString<L> *val);
- size_t arrayLength(const char*);
+ std::size_t arrayLength(const char*);
// stringLength returns the length of the string, including the null terminator.
- size_t stringLength(const char*);
+ std::size_t stringLength(const char*);
void setFields(int fields);
@@ -81,12 +81,12 @@ int MetalClawReader::op(const char*, T *val) {
return err;
};
-template<size_t L>
+template<std::size_t L>
int MetalClawReader::op(const char*, ox::BString<L> *val) {
int err = 0;
if (m_fieldPresence.get(m_field)) {
// read the length
- size_t size = 0;
+ std::size_t size = 0;
if (m_buffIt + sizeof(StringLength) < m_buffLen) {
size = *reinterpret_cast<LittleEndian<StringLength>*>(&m_buff[m_buffIt]);
m_buffIt += sizeof(StringLength);
@@ -130,11 +130,11 @@ int MetalClawReader::readInteger(I *val) {
};
template<typename T>
-int MetalClawReader::op(const char*, T *val, size_t valLen) {
+int MetalClawReader::op(const char*, T *val, std::size_t valLen) {
int err = 0;
if (m_fieldPresence.get(m_field)) {
// read the length
- size_t len = 0;
+ std::size_t len = 0;
if (m_buffIt + sizeof(ArrayLength) < m_buffLen) {
len = *reinterpret_cast<LittleEndian<ArrayLength>*>(&m_buff[m_buffIt]);
m_buffIt += sizeof(ArrayLength);
@@ -146,7 +146,7 @@ int MetalClawReader::op(const char*, T *val, size_t valLen) {
if (valLen >= len) {
MetalClawReader reader(m_buff + m_buffIt, m_buffLen - m_buffIt);
reader.setFields(len);
- for (size_t i = 0; i < len; i++) {
+ for (std::size_t i = 0; i < len; i++) {
err |= reader.op("", &val[i]);
}
m_buffIt += reader.m_buffIt;
@@ -159,7 +159,7 @@ int MetalClawReader::op(const char*, T *val, size_t valLen) {
};
template<typename T>
-int readMC(uint8_t *buff, size_t buffLen, T *val) {
+int readMC(uint8_t *buff, std::size_t buffLen, T *val) {
MetalClawReader reader(buff, buffLen);
return ioOp(&reader, val);
}
diff --git a/deps/ox/src/ox/mc/write.cpp b/deps/ox/src/ox/mc/write.cpp
index 6feaf82b..a9858478 100644
--- a/deps/ox/src/ox/mc/write.cpp
+++ b/deps/ox/src/ox/mc/write.cpp
@@ -12,7 +12,7 @@
namespace ox {
-MetalClawWriter::MetalClawWriter(uint8_t *buff, size_t buffLen): m_fieldPresence(buff, buffLen) {
+MetalClawWriter::MetalClawWriter(uint8_t *buff, std::size_t buffLen): m_fieldPresence(buff, buffLen) {
m_buff = buff;
m_buffLen = buffLen;
}
@@ -60,7 +60,7 @@ void MetalClawWriter::setFields(int fields) {
m_fieldPresence.setMaxLen(m_buffIt);
}
-size_t MetalClawWriter::size() {
+std::size_t MetalClawWriter::size() {
return m_buffIt;
}
diff --git a/deps/ox/src/ox/mc/write.hpp b/deps/ox/src/ox/mc/write.hpp
index 628d5bf2..9eb81ace 100644
--- a/deps/ox/src/ox/mc/write.hpp
+++ b/deps/ox/src/ox/mc/write.hpp
@@ -23,12 +23,12 @@ class MetalClawWriter {
FieldPresenseMask m_fieldPresence;
int m_fields = 0;
int m_field = 0;
- size_t m_buffIt = 0;
- size_t m_buffLen = 0;
+ std::size_t m_buffIt = 0;
+ std::size_t m_buffLen = 0;
uint8_t *m_buff = nullptr;
public:
- MetalClawWriter(uint8_t *buff, size_t buffLen);
+ MetalClawWriter(uint8_t *buff, std::size_t buffLen);
int op(const char*, int8_t *val);
int op(const char*, int16_t *val);
@@ -43,12 +43,12 @@ class MetalClawWriter {
int op(const char*, bool *val);
template<typename T>
- int op(const char*, T *val, size_t len);
+ int op(const char*, T *val, std::size_t len);
- template<size_t L>
+ template<std::size_t L>
int op(const char*, const char *val);
- template<size_t L>
+ template<std::size_t L>
int op(const char*, ox::BString<L> *val);
template<typename T>
@@ -56,7 +56,7 @@ class MetalClawWriter {
void setFields(int fields);
- size_t size();
+ std::size_t size();
OpType opType() {
return OpType::Write;
@@ -67,7 +67,7 @@ class MetalClawWriter {
int appendInteger(I val);
};
-template<size_t L>
+template<std::size_t L>
int MetalClawWriter::op(const char*, ox::BString<L> *val) {
int err = 0;
bool fieldSet = false;
@@ -97,7 +97,7 @@ int MetalClawWriter::op(const char*, T *val) {
bool fieldSet = false;
MetalClawWriter writer(m_buff + m_buffIt, m_buffLen - m_buffIt);
err |= ioOp(&writer, val);
- if (static_cast<size_t>(writer.m_fieldPresence.getMaxLen()) < writer.m_buffIt) {
+ if (static_cast<std::size_t>(writer.m_fieldPresence.getMaxLen()) < writer.m_buffIt) {
m_buffIt += writer.m_buffIt;
fieldSet = true;
}
@@ -125,7 +125,7 @@ int MetalClawWriter::appendInteger(I val) {
}
template<typename T>
-int MetalClawWriter::op(const char*, T *val, size_t len) {
+int MetalClawWriter::op(const char*, T *val, std::size_t len) {
int err = 0;
bool fieldSet = false;
@@ -143,7 +143,7 @@ int MetalClawWriter::op(const char*, T *val, size_t len) {
writer.setFields(len);
// write the array
- for (size_t i = 0; i < len; i++) {
+ for (std::size_t i = 0; i < len; i++) {
err |= writer.op("", &val[i]);
}
@@ -157,7 +157,7 @@ int MetalClawWriter::op(const char*, T *val, size_t len) {
}
template<typename T>
-int writeMC(uint8_t *buff, size_t buffLen, T *val, size_t *sizeOut = nullptr) {
+int writeMC(uint8_t *buff, std::size_t buffLen, T *val, std::size_t *sizeOut = nullptr) {
MetalClawWriter writer(buff, buffLen);
auto err = ioOp(&writer, val);
if (sizeOut) {
diff --git a/deps/ox/src/ox/std/assert.cpp b/deps/ox/src/ox/std/assert.cpp
index 388e12a2..668d2dfc 100644
--- a/deps/ox/src/ox/std/assert.cpp
+++ b/deps/ox/src/ox/std/assert.cpp
@@ -6,6 +6,8 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
+#include <iostream>
+
#include <ox/__buildinfo/defines.hpp>
namespace ox {
diff --git a/deps/ox/src/ox/std/memops.cpp b/deps/ox/src/ox/std/memops.cpp
index 2f067ee7..e7a17edb 100644
--- a/deps/ox/src/ox/std/memops.cpp
+++ b/deps/ox/src/ox/std/memops.cpp
@@ -9,11 +9,11 @@
#include "types.hpp"
-int ox_memcmp(const void *ptr1, const void *ptr2, size_t size) {
+int ox_memcmp(const void *ptr1, const void *ptr2, std::size_t size) noexcept {
int retval = 0;
auto block1 = reinterpret_cast<const uint8_t*>(ptr1);
auto block2 = reinterpret_cast<const uint8_t*>(ptr2);
- for (size_t i = 0; i < size; i++) {
+ for (std::size_t i = 0; i < size; i++) {
if (block1[i] < block2[i]) {
retval = -1;
break;
@@ -25,7 +25,7 @@ int ox_memcmp(const void *ptr1, const void *ptr2, size_t size) {
return retval;
}
-void *ox_memcpy(void *dest, const void *src, int64_t size) {
+void *ox_memcpy(void *dest, const void *src, int64_t size) noexcept {
char *srcBuf = (char*) src;
char *dstBuf = (char*) dest;
for (int64_t i = 0; i < size; i++) {
@@ -34,7 +34,7 @@ void *ox_memcpy(void *dest, const void *src, int64_t size) {
return dest;
}
-void *ox_memset(void *ptr, int val, int64_t size) {
+void *ox_memset(void *ptr, int val, int64_t size) noexcept {
char *buf = (char*) ptr;
for (int64_t i = 0; i < size; i++) {
buf[i] = val;
diff --git a/deps/ox/src/ox/std/memops.hpp b/deps/ox/src/ox/std/memops.hpp
index 21232910..1ad6775f 100644
--- a/deps/ox/src/ox/std/memops.hpp
+++ b/deps/ox/src/ox/std/memops.hpp
@@ -9,8 +9,8 @@
#include "types.hpp"
-int ox_memcmp(const void *ptr1, const void *ptr2, size_t size);
+int ox_memcmp(const void *ptr1, const void *ptr2, std::size_t size) noexcept;
-void *ox_memcpy(void *dest, const void *src, int64_t size);
+void *ox_memcpy(void *dest, const void *src, int64_t size) noexcept;
-void *ox_memset(void *ptr, int val, int64_t size);
+void *ox_memset(void *ptr, int val, int64_t size) noexcept;
diff --git a/deps/ox/src/ox/std/string.hpp b/deps/ox/src/ox/std/string.hpp
index ffaa9056..2fbf8448 100644
--- a/deps/ox/src/ox/std/string.hpp
+++ b/deps/ox/src/ox/std/string.hpp
@@ -15,70 +15,70 @@
namespace ox {
// Bounded String
-template<size_t buffLen>
+template<std::size_t buffLen>
class BString {
private:
uint8_t m_buff[buffLen];
public:
- BString();
+ BString() noexcept;
- BString(const char *str);
+ BString(const char *str) noexcept;
- const BString &operator=(const char *str);
+ const BString &operator=(const char *str) noexcept;
- const BString &operator=(char *str);
+ const BString &operator=(char *str) noexcept;
- const BString &operator=(int64_t i);
+ const BString &operator=(int64_t i) noexcept;
- const BString &operator+=(const char *str);
+ const BString &operator+=(const char *str) noexcept;
- const BString &operator+=(char *str);
+ const BString &operator+=(char *str) noexcept;
- const BString &operator+=(int64_t i);
+ const BString &operator+=(int64_t i) noexcept;
- bool operator==(const BString &other);
+ bool operator==(const BString &other) noexcept;
- char *data();
+ char *data() noexcept;
const char *c_str() noexcept;
/**
* Returns the number of characters in this string.
*/
- size_t len();
+ std::size_t len() noexcept;
/**
* Returns the number of bytes used for this string.
*/
- size_t size();
+ std::size_t size() noexcept;
/**
* Returns the capacity of bytes for this string.
*/
- size_t cap();
+ std::size_t cap() noexcept;
};
-template<size_t size>
-BString<size>::BString() {
+template<std::size_t size>
+BString<size>::BString() noexcept {
m_buff[0] = 0;
}
-template<size_t size>
-BString<size>::BString(const char *str) {
+template<std::size_t size>
+BString<size>::BString(const char *str) noexcept {
*this = str;
}
-template<size_t size>
-const BString<size> &BString<size>::operator=(int64_t i) {
+template<std::size_t size>
+const BString<size> &BString<size>::operator=(int64_t i) noexcept {
char str[65];
ox_itoa(i, str);
return this->operator=(str);
}
-template<size_t size>
-const BString<size> &BString<size>::operator=(const char *str) {
- size_t strLen = ox_strlen(str) + 1;
+template<std::size_t size>
+const BString<size> &BString<size>::operator=(const char *str) noexcept {
+ std::size_t strLen = ox_strlen(str) + 1;
if (cap() < strLen) {
strLen = cap();
}
@@ -88,14 +88,14 @@ const BString<size> &BString<size>::operator=(const char *str) {
return *this;
}
-template<size_t size>
-const BString<size> &BString<size>::operator=(char *str) {
+template<std::size_t size>
+const BString<size> &BString<size>::operator=(char *str) noexcept {
return *this = (const char*) str;
}
-template<size_t size>
-const BString<size> &BString<size>::operator+=(const char *str) {
- size_t strLen = ox_strlen(str) + 1;
+template<std::size_t size>
+const BString<size> &BString<size>::operator+=(const char *str) noexcept {
+ std::size_t strLen = ox_strlen(str) + 1;
auto currentLen = len();
if (cap() < currentLen + strLen) {
strLen = cap() - currentLen;
@@ -106,22 +106,22 @@ const BString<size> &BString<size>::operator+=(const char *str) {
return *this;
}
-template<size_t size>
-const BString<size> &BString<size>::operator+=(char *str) {
+template<std::size_t size>
+const BString<size> &BString<size>::operator+=(char *str) noexcept {
return *this += (const char*) str;
}
-template<size_t size>
-const BString<size> &BString<size>::operator+=(int64_t i) {
+template<std::size_t size>
+const BString<size> &BString<size>::operator+=(int64_t i) noexcept {
char str[65];
ox_itoa(i, str);
return this->operator+=(str);
}
-template<size_t buffLen>
-bool BString<buffLen>::operator==(const BString<buffLen> &other) {
+template<std::size_t buffLen>
+bool BString<buffLen>::operator==(const BString<buffLen> &other) noexcept {
bool retval = true;
- size_t i = 0;
+ std::size_t i = 0;
while (i < buffLen && (m_buff[i] || other.m_buff[i])) {
if (m_buff[i] != other.m_buff[i]) {
retval = false;
@@ -132,21 +132,21 @@ bool BString<buffLen>::operator==(const BString<buffLen> &other) {
return retval;
}
-template<size_t buffLen>
-char *BString<buffLen>::data() {
+template<std::size_t buffLen>
+char *BString<buffLen>::data() noexcept {
return (char*) m_buff;
}
-template<size_t buffLen>
+template<std::size_t buffLen>
const char *BString<buffLen>::c_str() noexcept {
return (const char*) m_buff;
}
-template<size_t buffLen>
-size_t BString<buffLen>::len() {
- size_t length = 0;
- for (size_t i = 0; i < buffLen; i++) {
+template<std::size_t buffLen>
+std::size_t BString<buffLen>::len() noexcept {
+ std::size_t length = 0;
+ for (std::size_t i = 0; i < buffLen; i++) {
uint8_t b = m_buff[i];
if (b) {
if ((b & 128) == 0) { // normal ASCII character
@@ -161,15 +161,15 @@ size_t BString<buffLen>::len() {
return length;
}
-template<size_t buffLen>
-size_t BString<buffLen>::size() {
- size_t i;
+template<std::size_t buffLen>
+std::size_t BString<buffLen>::size() noexcept {
+ std::size_t i;
for (i = 0; i < buffLen && m_buff[i]; i++);
return i + 1; // add one for null terminator
}
-template<size_t buffLen>
-size_t BString<buffLen>::cap() {
+template<std::size_t buffLen>
+std::size_t BString<buffLen>::cap() noexcept {
return buffLen;
}
diff --git a/deps/ox/src/ox/std/strops.hpp b/deps/ox/src/ox/std/strops.hpp
index 0b62e37b..67c47610 100644
--- a/deps/ox/src/ox/std/strops.hpp
+++ b/deps/ox/src/ox/std/strops.hpp
@@ -12,19 +12,19 @@
#include "types.hpp"
#include "typetraits.hpp"
-constexpr int ox_strlen(const char *str1) {
+constexpr int ox_strlen(const char *str1) noexcept {
int len = 0;
for (; str1[len]; len++);
return len;
}
-constexpr int ox_strlen(char *str1) {
+constexpr int ox_strlen(char *str1) noexcept {
int len = 0;
for (; str1[len]; len++);
return len;
}
-constexpr int ox_strcmp(const char *str1, const char *str2) {
+constexpr int ox_strcmp(const char *str1, const char *str2) noexcept {
auto retval = 0;
auto i = 0;
while (str1[i] || str2[i]) {
@@ -40,8 +40,8 @@ constexpr int ox_strcmp(const char *str1, const char *str2) {
return retval;
}
-constexpr const char *ox_strchr(const char *str, int character, size_t maxLen = 0xFFFFFFFF) {
- for (size_t i = 0; i <= maxLen; i++) {
+constexpr const char *ox_strchr(const char *str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
+ for (std::size_t i = 0; i <= maxLen; i++) {
if (str[i] == character) {
return &str[i];
} else if (str[i] == 0) {
@@ -51,8 +51,8 @@ constexpr const char *ox_strchr(const char *str, int character, size_t maxLen =
return nullptr;
}
-constexpr char *ox_strchr(char *str, int character, size_t maxLen = 0xFFFFFFFF) {
- for (size_t i = 0; i < maxLen; i++) {
+constexpr char *ox_strchr(char *str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
+ for (std::size_t i = 0; i < maxLen; i++) {
if (str[i] == character) {
return &str[i];
} else if (str[i] == 0) {
@@ -62,7 +62,7 @@ constexpr char *ox_strchr(char *str, int character, size_t maxLen = 0xFFFFFFFF)
return nullptr;
}
-constexpr int ox_lastIndexOf(const char *str, int character, int maxLen = 0xFFFFFFFF) {
+constexpr int ox_lastIndexOf(const char *str, int character, int maxLen = 0xFFFFFFFF) noexcept {
int retval = -1;
for (int i = 0; i < maxLen && str[i]; i++) {
if (str[i] == character) {
@@ -72,7 +72,7 @@ constexpr int ox_lastIndexOf(const char *str, int character, int maxLen = 0xFFFF
return retval;
}
-constexpr int ox_lastIndexOf(char *str, int character, int maxLen = 0xFFFFFFFF) {
+constexpr int ox_lastIndexOf(char *str, int character, int maxLen = 0xFFFFFFFF) noexcept {
int retval = -1;
for (int i = 0; i < maxLen && str[i]; i++) {
if (str[i] == character) {
@@ -82,7 +82,7 @@ constexpr int ox_lastIndexOf(char *str, int character, int maxLen = 0xFFFFFFFF)
return retval;
}
-constexpr int ox_atoi(const char *str) {
+constexpr int ox_atoi(const char *str) noexcept {
int total = 0;
int multiplier = 1;
@@ -94,7 +94,7 @@ constexpr int ox_atoi(const char *str) {
return total;
}
-constexpr char *ox_itoa(int64_t v, char *str) {
+constexpr char *ox_itoa(int64_t v, char *str) noexcept {
if (v) {
auto mod = 1000000000000000000;
constexpr auto base = 10;
diff --git a/deps/ox/src/ox/std/types.hpp b/deps/ox/src/ox/std/types.hpp
index 6de3a433..fbd44096 100644
--- a/deps/ox/src/ox/std/types.hpp
+++ b/deps/ox/src/ox/std/types.hpp
@@ -75,8 +75,6 @@ using size_t = decltype(alignof(int));
}
-using std::size_t;
-
static_assert(sizeof(int8_t) == 1, "int8_t is wrong size");
static_assert(sizeof(int16_t) == 2, "int16_t is wrong size");
static_assert(sizeof(int32_t) == 4, "int32_t is wrong size");
diff --git a/deps/ox/src/ox/std/vector.hpp b/deps/ox/src/ox/std/vector.hpp
index 44b18359..67ea829d 100644
--- a/deps/ox/src/ox/std/vector.hpp
+++ b/deps/ox/src/ox/std/vector.hpp
@@ -16,13 +16,13 @@ template<typename T>
class Vector {
private:
- size_t m_size = 0;
+ std::size_t m_size = 0;
T *m_items = nullptr;
public:
Vector() = default;
- explicit Vector(size_t size);
+ explicit Vector(std::size_t size);
Vector(Vector &other);
@@ -34,18 +34,18 @@ class Vector {
Vector &operator=(Vector &&other);
- T &operator[](size_t i);
+ T &operator[](std::size_t i);
- const T &operator[](size_t i) const;
+ const T &operator[](std::size_t i) const;
- size_t size() const;
+ std::size_t size() const;
- void resize(size_t size);
+ void resize(std::size_t size);
};
template<typename T>
-Vector<T>::Vector(size_t size) {
+Vector<T>::Vector(std::size_t size) {
m_size = size;
m_items = new T[m_size];
}
@@ -54,7 +54,7 @@ template<typename T>
Vector<T>::Vector(Vector<T> &other) {
m_size = other.m_size;
m_items = new T[m_size];
- for (size_t i = 0; i < m_size; i++) {
+ for (std::size_t i = 0; i < m_size; i++) {
m_items[i] = other.m_items[i];
}
}
@@ -80,7 +80,7 @@ Vector<T> &Vector<T>::operator=(Vector<T> &other) {
~Vector<T>();
m_size = other.m_size;
m_items = new T[m_size];
- for (size_t i = 0; i < m_size; i++) {
+ for (std::size_t i = 0; i < m_size; i++) {
m_items[i] = other.m_items[i];
}
return *this;
@@ -97,26 +97,26 @@ Vector<T> &Vector<T>::operator=(Vector<T> &&other) {
}
template<typename T>
-T &Vector<T>::operator[](size_t i) {
+T &Vector<T>::operator[](std::size_t i) {
return *(m_items[i]);
}
template<typename T>
-const T &Vector<T>::operator[](size_t i) const {
+const T &Vector<T>::operator[](std::size_t i) const {
return *(m_items[i]);
}
template<typename T>
-size_t Vector<T>::size() const {
+std::size_t Vector<T>::size() const {
return m_size;
};
template<typename T>
-void Vector<T>::resize(size_t size) {
+void Vector<T>::resize(std::size_t size) {
auto oldItems = m_items;
m_items = new T[size];
const auto itRange = size > m_size ? m_size : size;
- for (size_t i = 0; i < itRange; i++) {
+ for (std::size_t i = 0; i < itRange; i++) {
m_items[i] = oldItems[i];
}
m_size = size;
diff --git a/deps/ox/src/ox/trace/trace.hpp b/deps/ox/src/ox/trace/trace.hpp
index 827c6665..ff89279b 100644
--- a/deps/ox/src/ox/trace/trace.hpp
+++ b/deps/ox/src/ox/trace/trace.hpp
@@ -66,7 +66,7 @@ class StdOutStream {
~StdOutStream();
template<typename T>
- inline StdOutStream &operator<<(T v) {
+ inline StdOutStream &operator<<(const T &v) {
m_msg.msg += " ";
m_msg.msg += v;
return *this;