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
// 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;

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

@ -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) {

4
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);
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) {

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<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) {

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

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

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

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

@ -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;

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

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

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

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

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

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

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

@ -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) {

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

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

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

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

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

@ -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) {

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/.
*/
#include <iostream>
#include <ox/__buildinfo/defines.hpp>
namespace ox {

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

@ -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;

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

@ -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;

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

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

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

@ -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;

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(int16_t) == 2, "int16_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 {
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;

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

@ -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;