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

[ox/std] Remove ::size_t

Browse Source
This commit is contained in:
Gary Talent 2018-04-12 19:35:16 -05:00
parent ad62d4c012
commit b8c54eba0c
22 changed files with 213 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/ox/src/ox/fs/filestore.hpp vendored
View File

@ -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 // do byte-by-byte copy to ensure alignment is right when copying to
// final destination // final destination
T val; 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++); ((uint8_t*) (&val))[i] = *(it++);
} }
*(data++) = val; *(data++) = val;

64
deps/ox/src/ox/fs/filestore/ptr.hpp vendored
View File

@ -38,16 +38,24 @@ class Ptr {
inline size_t end(); 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 operator size_t() const;
inline T &operator*() const;
template<typename SubT> template<typename SubT>
inline Ptr<SubT, size_t, sizeof(T)> subPtr(size_t offset, size_t size); 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> 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(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::get())");
oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::get())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::get())");
return reinterpret_cast<T*>(m_dataStart + m_itemOffset); return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
} }
template<typename T, typename size_t, size_t minOffset> 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(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator->())");
oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator->())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator->())");
return reinterpret_cast<T*>(m_dataStart + m_itemOffset); return reinterpret_cast<T*>(m_dataStart + m_itemOffset);
} }
template<typename T, typename size_t, size_t minOffset> 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); 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> template<typename T, typename size_t, size_t minOffset>
inline Ptr<T, size_t, minOffset>::operator size_t() const { inline Ptr<T, size_t, minOffset>::operator size_t() const {
if (m_dataStart and m_itemOffset) { if (m_dataStart and m_itemOffset) {
@ -121,13 +162,6 @@ inline Ptr<T, size_t, minOffset>::operator size_t() const {
return 0; 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 T, typename size_t, size_t minOffset>
template<typename SubT> template<typename SubT>
inline Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset, size_t size) { inline Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset, size_t size) {

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

@ -86,7 +86,7 @@ struct __attribute__((packed)) Directory {
uint64_t getFileInode(const char *name); 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); 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> 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) { if (inodesLen >= this->children) {
auto current = files(); auto current = files();
if (current) { if (current) {
@ -205,4 +205,4 @@ int Directory<InodeId_t, FsSize_t>::ls(List *list) {
} }
} }
} }

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

@ -14,7 +14,7 @@ template class FileSystemTemplate<FileStore16, OxFS_16>;
template class FileSystemTemplate<FileStore32, OxFS_32>; template class FileSystemTemplate<FileStore32, OxFS_32>;
template class FileSystemTemplate<FileStore64, OxFS_64>; 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 version = ((FileStore16*) buff)->version();
auto type = ((FileStore16*) buff)->fsType(); auto type = ((FileStore16*) buff)->fsType();
FileSystem *fs = nullptr; FileSystem *fs = nullptr;
@ -45,7 +45,7 @@ FileSystem *createFileSystem(uint8_t *buff, size_t buffSize, bool ownsBuff) {
return fs; return fs;
} }
FileSystem *expandCopy(FileSystem *fs, size_t size) { FileSystem *expandCopy(FileSystem *fs, std::size_t size) {
auto fsBuff = fs->buff(); auto fsBuff = fs->buff();
FileSystem *retval = nullptr; FileSystem *retval = nullptr;
@ -61,7 +61,7 @@ FileSystem *expandCopy(FileSystem *fs, size_t size) {
return retval; return retval;
} }
FileSystem *expandCopyCleanup(FileSystem *fs, size_t size) { FileSystem *expandCopyCleanup(FileSystem *fs, std::size_t size) {
auto out = expandCopy(fs, size); auto out = expandCopy(fs, size);
if (!out) { if (!out) {

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

@ -33,13 +33,13 @@ class FileSystem {
template<typename List> template<typename List>
int ls(const char *path, List *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; 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; int err = 0;
auto s = stat(path); auto s = stat(path);
if (s.fileType == FileType_Directory) { 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; auto dir = (Directory<uint64_t, uint64_t>*) dirBuff;
err |= readDirectory(path, dir); err |= readDirectory(path, dir);
if (!err) { if (!err) {
@ -85,7 +85,7 @@ int FileSystem::ls(const char *path, List *list) {
return err; 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. * 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 * Calls expandCopy and deletes the original FileSystem and buff a resize was
* performed. * performed.
*/ */
FileSystem *expandCopyCleanup(FileSystem *fs, size_t size); FileSystem *expandCopyCleanup(FileSystem *fs, std::size_t size);
} }

32
deps/ox/src/ox/fs/filesystem/filesystemtemplate.hpp vendored
View File

@ -33,13 +33,13 @@ class FileSystemTemplate: public FileSystem {
int mkdir(const char *path, bool recursive = false) override; 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; void resize(uint64_t size = 0) override;
@ -201,7 +201,7 @@ FileStat FileSystemTemplate<FileStore, FS_TYPE>::stat(uint64_t inode) {
#pragma warning(disable:4244) #pragma warning(disable:4244)
#endif #endif
template<typename FileStore, FsType FS_TYPE> 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; int retval = -1;
// find the inode for the given path // 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) #pragma warning(disable:4244)
#endif #endif
template<typename FileStore, FsType FS_TYPE> 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); auto stat = m_store->stat(inode);
if (stat.size <= buffSize) { if (stat.size <= buffSize) {
return m_store->read(inode, buffer, nullptr); 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) #pragma warning(disable:4244)
#endif #endif
template<typename FileStore, FsType FS_TYPE> template<typename FileStore, FsType FS_TYPE>
int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, size_t readStart, int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, std::size_t readStart,
size_t readSize, void *buffer, std::size_t readSize, void *buffer,
size_t *size) { std::size_t *size) {
if (size) { if (size) {
auto stat = m_store->stat(inode); auto stat = m_store->stat(inode);
*size = stat.size; *size = stat.size;
@ -254,7 +254,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::read(uint64_t inode, size_t readStar
#pragma warning(disable:4244) #pragma warning(disable:4244)
#endif #endif
template<typename FileStore, FsType FS_TYPE> 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 s = m_store->stat(inode);
auto buff = new uint8_t[s.size]; auto buff = new uint8_t[s.size];
if (size) { if (size) {
@ -329,7 +329,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::remove(uint64_t inode, bool recursiv
template<typename FileStore, FsType FS_TYPE> template<typename FileStore, FsType FS_TYPE>
int FileSystemTemplate<FileStore, FS_TYPE>::write(const char *path, void *buffer, uint64_t size, uint8_t fileType) { int FileSystemTemplate<FileStore, FS_TYPE>::write(const char *path, void *buffer, uint64_t size, uint8_t fileType) {
int err = 0; int err = 0;
size_t pathLen = ox_strlen(path); std::size_t pathLen = ox_strlen(path);
char dirPath[pathLen]; char dirPath[pathLen];
char fileName[pathLen]; char fileName[pathLen];
PathIterator pathReader(path, pathLen); PathIterator pathReader(path, pathLen);
@ -484,7 +484,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::insertDirectoryEntry(const char *dir
auto s = stat(dirPath); auto s = stat(dirPath);
if (s.inode) { if (s.inode) {
auto spaceNeeded = DirectoryEntry<typename FileStore::InodeId_t>::spaceNeeded(fileName); 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]; uint8_t dirBuff[dirBuffSize];
int err = read(s.inode, 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) { if (inode && !stat(dest).inode) {
int err = 0; int err = 0;
size_t srcLen = ox_strlen(src); std::size_t srcLen = ox_strlen(src);
char srcDirPath[srcLen]; char srcDirPath[srcLen];
char srcFileName[srcLen]; char srcFileName[srcLen];
PathIterator srcPathReader(src, srcLen); PathIterator srcPathReader(src, srcLen);
@ -525,7 +525,7 @@ int FileSystemTemplate<FileStore, FS_TYPE>::move(const char *src, const char *de
return err; return err;
} }
size_t destLen = ox_strlen(dest); std::size_t destLen = ox_strlen(dest);
char destDirPath[destLen]; char destDirPath[destLen];
char destFileName[destLen]; char destFileName[destLen];
PathIterator destPathReader(dest, 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> template<typename FileStore, FsType FS_TYPE>
int FileSystemTemplate<FileStore, FS_TYPE>::rmDirectoryEntry(const char *path) { int FileSystemTemplate<FileStore, FS_TYPE>::rmDirectoryEntry(const char *path) {
int err = 0; int err = 0;
size_t pathLen = ox_strlen(path); std::size_t pathLen = ox_strlen(path);
char dirPath[pathLen]; char dirPath[pathLen];
char fileName[pathLen]; char fileName[pathLen];
PathIterator pathReader(path, 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; typedef Directory<typename FileStore::InodeId_t, typename FileStore::FsSize_t> Dir;
int err = 0; int err = 0;
auto dirStat = stat(path); 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]; uint8_t dirBuff[dirBuffLen];
auto dir = (Dir*) dirBuff; auto dir = (Dir*) dirBuff;

24
deps/ox/src/ox/fs/filesystem/pathiterator.cpp vendored
View File

@ -12,7 +12,7 @@
namespace ox { namespace ox {
PathIterator::PathIterator(const char *path, size_t maxSize) { PathIterator::PathIterator(const char *path, std::size_t maxSize) {
m_path = path; m_path = path;
m_maxSize = maxSize; m_maxSize = maxSize;
} }
@ -20,9 +20,9 @@ PathIterator::PathIterator(const char *path, size_t maxSize) {
/** /**
* @return 0 if no error * @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); int idx = ox_lastIndexOf(m_path, '/', m_maxSize);
size_t size = idx + 1; std::size_t size = idx + 1;
if (idx >= 0 && size < outSize) { if (idx >= 0 && size < outSize) {
ox_memcpy(out, m_path, size); ox_memcpy(out, m_path, size);
out[size] = 0; out[size] = 0;
@ -35,11 +35,11 @@ int PathIterator::dirPath(char *out, size_t outSize) {
/** /**
* @return 0 if no error * @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); auto idx = ox_lastIndexOf(m_path, '/', m_maxSize);
if (idx >= 0) { if (idx >= 0) {
idx++; // pass up the preceding / 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) { if (fileNameSize < outSize) {
ox_memcpy(out, &m_path[idx], fileNameSize); ox_memcpy(out, &m_path[idx], fileNameSize);
out[fileNameSize] = 0; out[fileNameSize] = 0;
@ -53,22 +53,22 @@ int PathIterator::fileName(char *out, size_t outSize) {
} }
// Gets the next item in the path // Gets the next item in the path
int PathIterator::next(char *pathOut, size_t pathOutSize) { int PathIterator::next(char *pathOut, std::size_t pathOutSize) {
size_t size = 0; std::size_t size = 0;
int retval = 1; int retval = 1;
if (m_iterator < m_maxSize && ox_strlen(&m_path[m_iterator])) { if (m_iterator < m_maxSize && ox_strlen(&m_path[m_iterator])) {
retval = 0; retval = 0;
if (m_path[m_iterator] == '/') { if (m_path[m_iterator] == '/') {
m_iterator++; m_iterator++;
} }
size_t start = m_iterator; std::size_t start = m_iterator;
// end is at the next / // end is at the next /
const char *substr = ox_strchr(&m_path[start], '/', m_maxSize - start); const char *substr = ox_strchr(&m_path[start], '/', m_maxSize - start);
// correct end if it is invalid, which happens if there is no next / // correct end if it is invalid, which happens if there is no next /
if (!substr) { if (!substr) {
substr = ox_strchr(&m_path[start], 0, m_maxSize - start); 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; size = end - start;
// cannot fit the output in the output parameter // cannot fit the output in the output parameter
if (size >= pathOutSize) { if (size >= pathOutSize) {
@ -86,9 +86,9 @@ int PathIterator::next(char *pathOut, size_t pathOutSize) {
} }
bool PathIterator::hasNext() { bool PathIterator::hasNext() {
size_t size = 0; std::size_t size = 0;
if (m_iterator < m_maxSize && ox_strlen(&m_path[m_iterator])) { 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] == '/') { if (m_path[start] == '/') {
start++; start++;
} }
@ -98,7 +98,7 @@ bool PathIterator::hasNext() {
if (!substr) { if (!substr) {
substr = ox_strchr(&m_path[start], 0, m_maxSize - start); 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; size = end - start;
} }
return size > 0; return size > 0;

12
deps/ox/src/ox/fs/filesystem/pathiterator.hpp vendored
View File

@ -15,26 +15,26 @@ namespace ox {
class PathIterator { class PathIterator {
private: private:
const char *m_path = nullptr; const char *m_path = nullptr;
size_t m_iterator = 0; std::size_t m_iterator = 0;
size_t m_maxSize = 0; std::size_t m_maxSize = 0;
public: public:
PathIterator(const char *path, size_t maxSize); PathIterator(const char *path, std::size_t maxSize);
/** /**
* @return 0 if no error * @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 * @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 * @return 0 if no error
*/ */
int next(char *pathOut, size_t pathOutSize); int next(char *pathOut, std::size_t pathOutSize);
bool hasNext(); bool hasNext();
}; };

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

@ -12,7 +12,7 @@
namespace ox { namespace ox {
FieldPresenseMask::FieldPresenseMask(uint8_t *mask, size_t maxLen) { FieldPresenseMask::FieldPresenseMask(uint8_t *mask, std::size_t maxLen) {
m_mask = mask; m_mask = mask;
m_maxLen = maxLen; m_maxLen = maxLen;
} }

2
deps/ox/src/ox/mc/presencemask.hpp vendored
View File

@ -18,7 +18,7 @@ class FieldPresenseMask {
int m_maxLen = 0; int m_maxLen = 0;
public: public:
FieldPresenseMask(uint8_t *mask, size_t maxLen); FieldPresenseMask(uint8_t *mask, std::size_t maxLen);
bool get(int i); bool get(int i);

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

@ -12,7 +12,7 @@
namespace ox { 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_buff = buff;
m_buffLen = buffLen; m_buffLen = buffLen;
} }
@ -55,8 +55,8 @@ int MetalClawReader::op(const char*, bool *val) {
return 0; return 0;
} }
size_t MetalClawReader::arrayLength(const char*) { std::size_t MetalClawReader::arrayLength(const char*) {
size_t len = 0; std::size_t len = 0;
if (m_fieldPresence.get(m_field)) { if (m_fieldPresence.get(m_field)) {
// read the length // read the length
if (m_buffIt + sizeof(ArrayLength) < m_buffLen) { if (m_buffIt + sizeof(ArrayLength) < m_buffLen) {
@ -66,8 +66,8 @@ size_t MetalClawReader::arrayLength(const char*) {
return len; return len;
} }
size_t MetalClawReader::stringLength(const char*) { std::size_t MetalClawReader::stringLength(const char*) {
size_t len = 0; std::size_t len = 0;
if (m_fieldPresence.get(m_field)) { if (m_fieldPresence.get(m_field)) {
// read the length // read the length
if (m_buffIt + sizeof(StringLength) < m_buffLen) { if (m_buffIt + sizeof(StringLength) < m_buffLen) {

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

@ -25,12 +25,12 @@ class MetalClawReader {
FieldPresenseMask m_fieldPresence; FieldPresenseMask m_fieldPresence;
int m_fields = 0; int m_fields = 0;
int m_field = 0; int m_field = 0;
size_t m_buffIt = 0; std::size_t m_buffIt = 0;
size_t m_buffLen = 0; std::size_t m_buffLen = 0;
uint8_t *m_buff = nullptr; uint8_t *m_buff = nullptr;
public: 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*, int8_t *val);
int op(const char*, int16_t *val); int op(const char*, int16_t *val);
@ -45,18 +45,18 @@ class MetalClawReader {
int op(const char*, bool *val); int op(const char*, bool *val);
template<typename T> 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> template<typename T>
int op(const char*, T *val); int op(const char*, T *val);
template<size_t L> template<std::size_t L>
int op(const char*, ox::BString<L> *val); 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. // 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); void setFields(int fields);
@ -81,12 +81,12 @@ int MetalClawReader::op(const char*, T *val) {
return err; return err;
}; };
template<size_t L> template<std::size_t L>
int MetalClawReader::op(const char*, ox::BString<L> *val) { int MetalClawReader::op(const char*, ox::BString<L> *val) {
int err = 0; int err = 0;
if (m_fieldPresence.get(m_field)) { if (m_fieldPresence.get(m_field)) {
// read the length // read the length
size_t size = 0; std::size_t size = 0;
if (m_buffIt + sizeof(StringLength) < m_buffLen) { if (m_buffIt + sizeof(StringLength) < m_buffLen) {
size = *reinterpret_cast<LittleEndian<StringLength>*>(&m_buff[m_buffIt]); size = *reinterpret_cast<LittleEndian<StringLength>*>(&m_buff[m_buffIt]);
m_buffIt += sizeof(StringLength); m_buffIt += sizeof(StringLength);
@ -130,11 +130,11 @@ int MetalClawReader::readInteger(I *val) {
}; };
template<typename T> 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; int err = 0;
if (m_fieldPresence.get(m_field)) { if (m_fieldPresence.get(m_field)) {
// read the length // read the length
size_t len = 0; std::size_t len = 0;
if (m_buffIt + sizeof(ArrayLength) < m_buffLen) { if (m_buffIt + sizeof(ArrayLength) < m_buffLen) {
len = *reinterpret_cast<LittleEndian<ArrayLength>*>(&m_buff[m_buffIt]); len = *reinterpret_cast<LittleEndian<ArrayLength>*>(&m_buff[m_buffIt]);
m_buffIt += sizeof(ArrayLength); m_buffIt += sizeof(ArrayLength);
@ -146,7 +146,7 @@ int MetalClawReader::op(const char*, T *val, size_t valLen) {
if (valLen >= len) { if (valLen >= len) {
MetalClawReader reader(m_buff + m_buffIt, m_buffLen - m_buffIt); MetalClawReader reader(m_buff + m_buffIt, m_buffLen - m_buffIt);
reader.setFields(len); 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]); err |= reader.op("", &val[i]);
} }
m_buffIt += reader.m_buffIt; m_buffIt += reader.m_buffIt;
@ -159,7 +159,7 @@ int MetalClawReader::op(const char*, T *val, size_t valLen) {
}; };
template<typename T> 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); MetalClawReader reader(buff, buffLen);
return ioOp(&reader, val); return ioOp(&reader, val);
} }

4
deps/ox/src/ox/mc/write.cpp vendored
View File

@ -12,7 +12,7 @@
namespace ox { 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_buff = buff;
m_buffLen = buffLen; m_buffLen = buffLen;
} }
@ -60,7 +60,7 @@ void MetalClawWriter::setFields(int fields) {
m_fieldPresence.setMaxLen(m_buffIt); m_fieldPresence.setMaxLen(m_buffIt);
} }
size_t MetalClawWriter::size() { std::size_t MetalClawWriter::size() {
return m_buffIt; return m_buffIt;
} }

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

@ -23,12 +23,12 @@ class MetalClawWriter {
FieldPresenseMask m_fieldPresence; FieldPresenseMask m_fieldPresence;
int m_fields = 0; int m_fields = 0;
int m_field = 0; int m_field = 0;
size_t m_buffIt = 0; std::size_t m_buffIt = 0;
size_t m_buffLen = 0; std::size_t m_buffLen = 0;
uint8_t *m_buff = nullptr; uint8_t *m_buff = nullptr;
public: 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*, int8_t *val);
int op(const char*, int16_t *val); int op(const char*, int16_t *val);
@ -43,12 +43,12 @@ class MetalClawWriter {
int op(const char*, bool *val); int op(const char*, bool *val);
template<typename T> 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); int op(const char*, const char *val);
template<size_t L> template<std::size_t L>
int op(const char*, ox::BString<L> *val); int op(const char*, ox::BString<L> *val);
template<typename T> template<typename T>
@ -56,7 +56,7 @@ class MetalClawWriter {
void setFields(int fields); void setFields(int fields);
size_t size(); std::size_t size();
OpType opType() { OpType opType() {
return OpType::Write; return OpType::Write;
@ -67,7 +67,7 @@ class MetalClawWriter {
int appendInteger(I val); int appendInteger(I val);
}; };
template<size_t L> template<std::size_t L>
int MetalClawWriter::op(const char*, ox::BString<L> *val) { int MetalClawWriter::op(const char*, ox::BString<L> *val) {
int err = 0; int err = 0;
bool fieldSet = false; bool fieldSet = false;
@ -97,7 +97,7 @@ int MetalClawWriter::op(const char*, T *val) {
bool fieldSet = false; bool fieldSet = false;
MetalClawWriter writer(m_buff + m_buffIt, m_buffLen - m_buffIt); MetalClawWriter writer(m_buff + m_buffIt, m_buffLen - m_buffIt);
err |= ioOp(&writer, val); 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; m_buffIt += writer.m_buffIt;
fieldSet = true; fieldSet = true;
} }
@ -125,7 +125,7 @@ int MetalClawWriter::appendInteger(I val) {
} }
template<typename T> 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; int err = 0;
bool fieldSet = false; bool fieldSet = false;
@ -143,7 +143,7 @@ int MetalClawWriter::op(const char*, T *val, size_t len) {
writer.setFields(len); writer.setFields(len);
// write the array // 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]); err |= writer.op("", &val[i]);
} }
@ -157,7 +157,7 @@ int MetalClawWriter::op(const char*, T *val, size_t len) {
} }
template<typename T> 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); MetalClawWriter writer(buff, buffLen);
auto err = ioOp(&writer, val); auto err = ioOp(&writer, val);
if (sizeOut) { if (sizeOut) {

2
deps/ox/src/ox/std/assert.cpp vendored
View File

@ -6,6 +6,8 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/ */
#include <iostream>
#include <ox/__buildinfo/defines.hpp> #include <ox/__buildinfo/defines.hpp>
namespace ox { namespace ox {

8
deps/ox/src/ox/std/memops.cpp vendored
View File

@ -9,11 +9,11 @@
#include "types.hpp" #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; int retval = 0;
auto block1 = reinterpret_cast<const uint8_t*>(ptr1); auto block1 = reinterpret_cast<const uint8_t*>(ptr1);
auto block2 = reinterpret_cast<const uint8_t*>(ptr2); 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]) { if (block1[i] < block2[i]) {
retval = -1; retval = -1;
break; break;
@ -25,7 +25,7 @@ int ox_memcmp(const void *ptr1, const void *ptr2, size_t size) {
return retval; 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 *srcBuf = (char*) src;
char *dstBuf = (char*) dest; char *dstBuf = (char*) dest;
for (int64_t i = 0; i < size; i++) { 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; 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; char *buf = (char*) ptr;
for (int64_t i = 0; i < size; i++) { for (int64_t i = 0; i < size; i++) {
buf[i] = val; buf[i] = val;

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

@ -9,8 +9,8 @@
#include "types.hpp" #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;

94
deps/ox/src/ox/std/string.hpp vendored
View File

@ -15,70 +15,70 @@
namespace ox { namespace ox {
// Bounded String // Bounded String
template<size_t buffLen> template<std::size_t buffLen>
class BString { class BString {
private: private:
uint8_t m_buff[buffLen]; uint8_t m_buff[buffLen];
public: 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; const char *c_str() noexcept;
/** /**
* Returns the number of characters in this string. * 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. * 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. * Returns the capacity of bytes for this string.
*/ */
size_t cap(); std::size_t cap() noexcept;
}; };
template<size_t size> template<std::size_t size>
BString<size>::BString() { BString<size>::BString() noexcept {
m_buff[0] = 0; m_buff[0] = 0;
} }
template<size_t size> template<std::size_t size>
BString<size>::BString(const char *str) { BString<size>::BString(const char *str) noexcept {
*this = str; *this = str;
} }
template<size_t size> template<std::size_t size>
const BString<size> &BString<size>::operator=(int64_t i) { const BString<size> &BString<size>::operator=(int64_t i) noexcept {
char str[65]; char str[65];
ox_itoa(i, str); ox_itoa(i, str);
return this->operator=(str); return this->operator=(str);
} }
template<size_t size> template<std::size_t size>
const BString<size> &BString<size>::operator=(const char *str) { const BString<size> &BString<size>::operator=(const char *str) noexcept {
size_t strLen = ox_strlen(str) + 1; std::size_t strLen = ox_strlen(str) + 1;
if (cap() < strLen) { if (cap() < strLen) {
strLen = cap(); strLen = cap();
} }
@ -88,14 +88,14 @@ const BString<size> &BString<size>::operator=(const char *str) {
return *this; return *this;
} }
template<size_t size> template<std::size_t size>
const BString<size> &BString<size>::operator=(char *str) { const BString<size> &BString<size>::operator=(char *str) noexcept {
return *this = (const char*) str; return *this = (const char*) str;
} }
template<size_t size> template<std::size_t size>
const BString<size> &BString<size>::operator+=(const char *str) { const BString<size> &BString<size>::operator+=(const char *str) noexcept {
size_t strLen = ox_strlen(str) + 1; std::size_t strLen = ox_strlen(str) + 1;
auto currentLen = len(); auto currentLen = len();
if (cap() < currentLen + strLen) { if (cap() < currentLen + strLen) {
strLen = cap() - currentLen; strLen = cap() - currentLen;
@ -106,22 +106,22 @@ const BString<size> &BString<size>::operator+=(const char *str) {
return *this; return *this;
} }
template<size_t size> template<std::size_t size>
const BString<size> &BString<size>::operator+=(char *str) { const BString<size> &BString<size>::operator+=(char *str) noexcept {
return *this += (const char*) str; return *this += (const char*) str;
} }
template<size_t size> template<std::size_t size>
const BString<size> &BString<size>::operator+=(int64_t i) { const BString<size> &BString<size>::operator+=(int64_t i) noexcept {
char str[65]; char str[65];
ox_itoa(i, str); ox_itoa(i, str);
return this->operator+=(str); return this->operator+=(str);
} }
template<size_t buffLen> template<std::size_t buffLen>
bool BString<buffLen>::operator==(const BString<buffLen> &other) { bool BString<buffLen>::operator==(const BString<buffLen> &other) noexcept {
bool retval = true; bool retval = true;
size_t i = 0; std::size_t i = 0;
while (i < buffLen && (m_buff[i] || other.m_buff[i])) { while (i < buffLen && (m_buff[i] || other.m_buff[i])) {
if (m_buff[i] != other.m_buff[i]) { if (m_buff[i] != other.m_buff[i]) {
retval = false; retval = false;
@ -132,21 +132,21 @@ bool BString<buffLen>::operator==(const BString<buffLen> &other) {
return retval; return retval;
} }
template<size_t buffLen> template<std::size_t buffLen>
char *BString<buffLen>::data() { char *BString<buffLen>::data() noexcept {
return (char*) m_buff; return (char*) m_buff;
} }
template<size_t buffLen> template<std::size_t buffLen>
const char *BString<buffLen>::c_str() noexcept { const char *BString<buffLen>::c_str() noexcept {
return (const char*) m_buff; return (const char*) m_buff;
} }
template<size_t buffLen> template<std::size_t buffLen>
size_t BString<buffLen>::len() { std::size_t BString<buffLen>::len() noexcept {
size_t length = 0; std::size_t length = 0;
for (size_t i = 0; i < buffLen; i++) { for (std::size_t i = 0; i < buffLen; i++) {
uint8_t b = m_buff[i]; uint8_t b = m_buff[i];
if (b) { if (b) {
if ((b & 128) == 0) { // normal ASCII character if ((b & 128) == 0) { // normal ASCII character
@ -161,15 +161,15 @@ size_t BString<buffLen>::len() {
return length; return length;
} }
template<size_t buffLen> template<std::size_t buffLen>
size_t BString<buffLen>::size() { std::size_t BString<buffLen>::size() noexcept {
size_t i; std::size_t i;
for (i = 0; i < buffLen && m_buff[i]; i++); for (i = 0; i < buffLen && m_buff[i]; i++);
return i + 1; // add one for null terminator return i + 1; // add one for null terminator
} }
template<size_t buffLen> template<std::size_t buffLen>
size_t BString<buffLen>::cap() { std::size_t BString<buffLen>::cap() noexcept {
return buffLen; return buffLen;
} }

22
deps/ox/src/ox/std/strops.hpp vendored
View File

@ -12,19 +12,19 @@
#include "types.hpp" #include "types.hpp"
#include "typetraits.hpp" #include "typetraits.hpp"
constexpr int ox_strlen(const char *str1) { constexpr int ox_strlen(const char *str1) noexcept {
int len = 0; int len = 0;
for (; str1[len]; len++); for (; str1[len]; len++);
return len; return len;
} }
constexpr int ox_strlen(char *str1) { constexpr int ox_strlen(char *str1) noexcept {
int len = 0; int len = 0;
for (; str1[len]; len++); for (; str1[len]; len++);
return 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 retval = 0;
auto i = 0; auto i = 0;
while (str1[i] || str2[i]) { while (str1[i] || str2[i]) {
@ -40,8 +40,8 @@ constexpr int ox_strcmp(const char *str1, const char *str2) {
return retval; return retval;
} }
constexpr const char *ox_strchr(const char *str, int character, size_t maxLen = 0xFFFFFFFF) { constexpr const char *ox_strchr(const char *str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
for (size_t i = 0; i <= maxLen; i++) { for (std::size_t i = 0; i <= maxLen; i++) {
if (str[i] == character) { if (str[i] == character) {
return &str[i]; return &str[i];
} else if (str[i] == 0) { } else if (str[i] == 0) {
@ -51,8 +51,8 @@ constexpr const char *ox_strchr(const char *str, int character, size_t maxLen =
return nullptr; return nullptr;
} }
constexpr char *ox_strchr(char *str, int character, size_t maxLen = 0xFFFFFFFF) { constexpr char *ox_strchr(char *str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
for (size_t i = 0; i < maxLen; i++) { for (std::size_t i = 0; i < maxLen; i++) {
if (str[i] == character) { if (str[i] == character) {
return &str[i]; return &str[i];
} else if (str[i] == 0) { } else if (str[i] == 0) {
@ -62,7 +62,7 @@ constexpr char *ox_strchr(char *str, int character, size_t maxLen = 0xFFFFFFFF)
return nullptr; 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; int retval = -1;
for (int i = 0; i < maxLen && str[i]; i++) { for (int i = 0; i < maxLen && str[i]; i++) {
if (str[i] == character) { if (str[i] == character) {
@ -72,7 +72,7 @@ constexpr int ox_lastIndexOf(const char *str, int character, int maxLen = 0xFFFF
return retval; 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; int retval = -1;
for (int i = 0; i < maxLen && str[i]; i++) { for (int i = 0; i < maxLen && str[i]; i++) {
if (str[i] == character) { if (str[i] == character) {
@ -82,7 +82,7 @@ constexpr int ox_lastIndexOf(char *str, int character, int maxLen = 0xFFFFFFFF)
return retval; return retval;
} }
constexpr int ox_atoi(const char *str) { constexpr int ox_atoi(const char *str) noexcept {
int total = 0; int total = 0;
int multiplier = 1; int multiplier = 1;
@ -94,7 +94,7 @@ constexpr int ox_atoi(const char *str) {
return total; return total;
} }
constexpr char *ox_itoa(int64_t v, char *str) { constexpr char *ox_itoa(int64_t v, char *str) noexcept {
if (v) { if (v) {
auto mod = 1000000000000000000; auto mod = 1000000000000000000;
constexpr auto base = 10; constexpr auto base = 10;

2
deps/ox/src/ox/std/types.hpp vendored
View File

@ -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(int8_t) == 1, "int8_t is wrong size");
static_assert(sizeof(int16_t) == 2, "int16_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"); static_assert(sizeof(int32_t) == 4, "int32_t is wrong size");

28
deps/ox/src/ox/std/vector.hpp vendored
View File

@ -16,13 +16,13 @@ template<typename T>
class Vector { class Vector {
private: private:
size_t m_size = 0; std::size_t m_size = 0;
T *m_items = nullptr; T *m_items = nullptr;
public: public:
Vector() = default; Vector() = default;
explicit Vector(size_t size); explicit Vector(std::size_t size);
Vector(Vector &other); Vector(Vector &other);
@ -34,18 +34,18 @@ class Vector {
Vector &operator=(Vector &&other); 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> template<typename T>
Vector<T>::Vector(size_t size) { Vector<T>::Vector(std::size_t size) {
m_size = size; m_size = size;
m_items = new T[m_size]; m_items = new T[m_size];
} }
@ -54,7 +54,7 @@ template<typename T>
Vector<T>::Vector(Vector<T> &other) { Vector<T>::Vector(Vector<T> &other) {
m_size = other.m_size; m_size = other.m_size;
m_items = new T[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]; m_items[i] = other.m_items[i];
} }
} }
@ -80,7 +80,7 @@ Vector<T> &Vector<T>::operator=(Vector<T> &other) {
~Vector<T>(); ~Vector<T>();
m_size = other.m_size; m_size = other.m_size;
m_items = new T[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]; m_items[i] = other.m_items[i];
} }
return *this; return *this;
@ -97,26 +97,26 @@ Vector<T> &Vector<T>::operator=(Vector<T> &&other) {
} }
template<typename T> template<typename T>
T &Vector<T>::operator[](size_t i) { T &Vector<T>::operator[](std::size_t i) {
return *(m_items[i]); return *(m_items[i]);
} }
template<typename T> 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]); return *(m_items[i]);
} }
template<typename T> template<typename T>
size_t Vector<T>::size() const { std::size_t Vector<T>::size() const {
return m_size; return m_size;
}; };
template<typename T> template<typename T>
void Vector<T>::resize(size_t size) { void Vector<T>::resize(std::size_t size) {
auto oldItems = m_items; auto oldItems = m_items;
m_items = new T[size]; m_items = new T[size];
const auto itRange = size > m_size ? m_size : 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_items[i] = oldItems[i];
} }
m_size = size; m_size = size;

2
deps/ox/src/ox/trace/trace.hpp vendored
View File

@ -66,7 +66,7 @@ class StdOutStream {
~StdOutStream(); ~StdOutStream();
template<typename T> template<typename T>
inline StdOutStream &operator<<(T v) { inline StdOutStream &operator<<(const T &v) {
m_msg.msg += " "; m_msg.msg += " ";
m_msg.msg += v; m_msg.msg += v;
return *this; return *this;