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

[ox] Cleanup unnecessary ox::

Browse Source
This commit is contained in:
Gary Talent 2020-10-16 19:52:46 -05:00
parent 99a2ad8fc9
commit fe40b2e144
13 changed files with 59 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/ox/src/ox/claw/write.hpp vendored
View File

@ -28,7 +28,7 @@ struct TypeInfoCatcher {
this->name = name;
}
constexpr ox::Error field(...) noexcept {
constexpr Error field(...) noexcept {
return OxError(0);
}

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

@ -412,7 +412,7 @@ const ptrarith::Ptr<uint8_t, std::size_t> FileStoreTemplate<size_t>::read(InodeI
}
template<typename size_t>
ox::Error FileStoreTemplate<size_t>::resize() {
Error FileStoreTemplate<size_t>::resize() {
oxReturnError(compact());
const auto newSize = size() - available();
oxTrace("ox::fs::FileStoreTemplate::resize") << "resize to:" << newSize;
@ -492,9 +492,9 @@ Result<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>:
}
template<typename size_t>
ox::Error FileStoreTemplate<size_t>::compact() {
Error FileStoreTemplate<size_t>::compact() {
auto isFirstItem = true;
return m_buffer->compact([this, &isFirstItem](uint64_t oldAddr, ItemPtr item) -> ox::Error {
return m_buffer->compact([this, &isFirstItem](uint64_t oldAddr, ItemPtr item) -> Error {
if (isFirstItem) {
isFirstItem = false;
return OxError(0);

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

@ -130,7 +130,7 @@ Directory<FileStore, InodeId_t>::Directory(FileStore fs, InodeId_t inodeId) {
}
template<typename FileStore, typename InodeId_t>
ox::Error Directory<FileStore, InodeId_t>::init() noexcept {
Error Directory<FileStore, InodeId_t>::init() noexcept {
constexpr auto Size = sizeof(Buffer);
oxTrace("ox::fs::Directory::init") << "Initializing Directory with Inode ID:" << m_inodeId;
oxReturnError(m_fs.write(m_inodeId, nullptr, Size, FileType_Directory));
@ -145,7 +145,7 @@ ox::Error Directory<FileStore, InodeId_t>::init() noexcept {
}
template<typename FileStore, typename InodeId_t>
ox::Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
if (path.valid()) {
oxTrace("ox::fs::Directory::mkdir") << path.fullPath();
// reuse nameBuff if it has already been allocated, as it is a rather large variable
@ -190,7 +190,7 @@ ox::Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents
}
template<typename FileStore, typename InodeId_t>
ox::Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode, FileName *nameBuff) noexcept {
Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode, FileName *nameBuff) noexcept {
// reuse nameBuff if it has already been allocated, as it is a rather large variable
if (nameBuff == nullptr) {
nameBuff = reinterpret_cast<FileName*>(ox_alloca(sizeof(FileName)));
@ -261,7 +261,7 @@ ox::Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t in
}
template<typename FileStore, typename InodeId_t>
ox::Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameBuff) noexcept {
Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameBuff) noexcept {
// reuse nameBuff if it has already been allocated, as it is a rather large variable
if (nameBuff == nullptr) {
nameBuff = reinterpret_cast<FileName*>(ox_alloca(sizeof(FileName)));
@ -292,7 +292,7 @@ ox::Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *n
template<typename FileStore, typename InodeId_t>
template<typename F>
ox::Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
oxTrace("ox::fs::Directory::ls");
auto buff = m_fs.read(m_inodeId).template to<Buffer>();
if (!buff.valid()) {

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

@ -23,7 +23,7 @@ enum class FileAddressType: int8_t {
class FileAddress {
template<typename T>
friend ox::Error model(T*, FileAddress*);
friend Error model(T*, FileAddress*);
public:
static constexpr auto TypeName = "net.drinkingtea.ox.FileAddress";
@ -95,7 +95,7 @@ class FileAddress {
};
template<typename T>
ox::Error model(T *io, FileAddress::Data *obj) {
Error model(T *io, FileAddress::Data *obj) {
io->template setTypeInfo<FileAddress::Data>();
oxReturnError(io->field("path", SerStr(&obj->path)));
oxReturnError(io->field("constPath", SerStr(&obj->path)));
@ -104,7 +104,7 @@ ox::Error model(T *io, FileAddress::Data *obj) {
}
template<typename T>
ox::Error model(T *io, FileAddress *fa) {
Error model(T *io, FileAddress *fa) {
io->template setTypeInfo<FileAddress>();
oxReturnError(io->field("type", bit_cast<int8_t*>(&fa->m_type)));
oxReturnError(io->field("data", UnionView(&fa->m_data, static_cast<int>(fa->m_type))));

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

@ -58,7 +58,7 @@ Error FileSystem::remove(FileAddress addr, bool recursive) {
}
}
ox::Error FileSystem::write(FileAddress addr, void *buffer, uint64_t size, uint8_t fileType) {
Error FileSystem::write(FileAddress addr, void *buffer, uint64_t size, uint8_t fileType) {
switch (addr.type()) {
case FileAddressType::Inode:
return write(addr.getInode().value, buffer, size, fileType);
@ -70,7 +70,7 @@ ox::Error FileSystem::write(FileAddress addr, void *buffer, uint64_t size, uint8
}
}
ox::Result<FileStat> FileSystem::stat(FileAddress addr) {
Result<FileStat> FileSystem::stat(FileAddress addr) {
switch (addr.type()) {
case FileAddressType::Inode:
return stat(addr.getInode().value);

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

@ -72,7 +72,7 @@ class FileSystem {
[[nodiscard]] virtual char *buff() = 0;
virtual Error walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) = 0;
virtual Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) = 0;
[[nodiscard]] virtual bool valid() const = 0;
@ -149,7 +149,7 @@ class FileSystemTemplate: public FileSystem {
char *buff() override;
Error walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) override;
Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) override;
bool valid() const override;
@ -184,7 +184,7 @@ FileSystemTemplate<FileStore, Directory>::~FileSystemTemplate() {
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buffSize) {
Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buffSize) {
oxReturnError(FileStore::format(buff, buffSize));
FileStore fs(buff, buffSize);
@ -206,7 +206,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::mkdir(const char *path, bool recursive) {
Error FileSystemTemplate<FileStore, Directory>::mkdir(const char *path, bool recursive) {
oxTrace("ox::fs::FileSystemTemplate::mkdir") << "path:" << path << "recursive:" << recursive;
auto rootDir = this->rootDir();
oxReturnError(rootDir.error);
@ -214,7 +214,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::mkdir(const char *path, bool
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::move(const char *src, const char *dest) {
Error FileSystemTemplate<FileStore, Directory>::move(const char *src, const char *dest) {
auto fd = fileSystemData();
oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode);
@ -226,7 +226,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::move(const char *src, const
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::read(const char *path, void *buffer, std::size_t buffSize) {
Error FileSystemTemplate<FileStore, Directory>::read(const char *path, void *buffer, std::size_t buffSize) {
auto fd = fileSystemData();
oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode);
@ -246,12 +246,12 @@ Result<uint8_t*> FileSystemTemplate<FileStore, Directory>::read(const char *path
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, void *buffer, std::size_t buffSize) {
Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, void *buffer, std::size_t buffSize) {
return m_fs.read(inode, buffer, buffSize);
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) {
Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) {
return m_fs.read(inode, readStart, readSize, reinterpret_cast<uint8_t*>(buffer), size);
}
@ -266,7 +266,7 @@ Result<uint8_t*> FileSystemTemplate<FileStore, Directory>::read(uint64_t inode)
template<typename FileStore, typename Directory>
template<typename F>
ox::Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
oxTrace("ox::FileSystemTemplate::ls") << "path:" << path;
auto [s, err] = stat(path);
oxReturnError(err);
@ -275,7 +275,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool recursive) {
Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool recursive) {
auto fd = fileSystemData();
oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode);
@ -297,18 +297,18 @@ ox::Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, boo
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::resize() {
Error FileSystemTemplate<FileStore, Directory>::resize() {
return m_fs.resize();
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::resize(uint64_t size, void *buffer) {
Error FileSystemTemplate<FileStore, Directory>::resize(uint64_t size, void *buffer) {
oxReturnError(m_fs.resize(size, buffer));
return OxError(0);
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::write(const char *path, void *buffer, uint64_t size, uint8_t fileType) {
Error FileSystemTemplate<FileStore, Directory>::write(const char *path, void *buffer, uint64_t size, uint8_t fileType) {
auto [inode, err] = find(path);
if (err) {
auto generated = m_fs.generateInodeId();
@ -323,7 +323,7 @@ ox::Error FileSystemTemplate<FileStore, Directory>::write(const char *path, void
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType) {
Error FileSystemTemplate<FileStore, Directory>::write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType) {
return m_fs.write(inode, buffer, size, fileType);
}
@ -368,7 +368,7 @@ char *FileSystemTemplate<FileStore, Directory>::buff() {
}
template<typename FileStore, typename Directory>
ox::Error FileSystemTemplate<FileStore, Directory>::walk(ox::Error(*cb)(uint8_t, uint64_t, uint64_t)) {
Error FileSystemTemplate<FileStore, Directory>::walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) {
return m_fs.walk(cb);
}

2
deps/ox/src/ox/fs/filesystem/passthroughfs.cpp vendored
View File

@ -90,7 +90,7 @@ Error PassThroughFS::remove(const char *path, bool recursive) {
}
}
ox::Error PassThroughFS::resize(uint64_t, void*) {
Error PassThroughFS::resize(uint64_t, void*) {
// unsupported
return OxError(1);
}

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

@ -37,34 +37,34 @@ class PassThroughFS: public FileSystem {
[[nodiscard]] std::string basePath();
ox::Error mkdir(const char *path, bool recursive = false) override;
Error mkdir(const char *path, bool recursive = false) override;
ox::Error move(const char *src, const char *dest) override;
Error move(const char *src, const char *dest) override;
ox::Error read(const char *path, void *buffer, std::size_t buffSize) override;
Error read(const char *path, void *buffer, std::size_t buffSize) override;
ox::Result<uint8_t*> read(const char*) override;
Result<uint8_t*> read(const char*) override;
ox::Error read(uint64_t inode, void *buffer, std::size_t size) override;
Error read(uint64_t inode, void *buffer, std::size_t size) override;
ox::Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
ox::Result<uint8_t*> read(uint64_t) override;
Result<uint8_t*> read(uint64_t) override;
template<typename F>
ox::Error ls(const char *dir, F cb);
Error ls(const char *dir, F cb);
ox::Error remove(const char *path, bool recursive = false) override;
Error remove(const char *path, bool recursive = false) override;
ox::Error resize(uint64_t size, void *buffer = nullptr) override;
Error resize(uint64_t size, void *buffer = nullptr) override;
ox::Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
ox::Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
ox::Result<FileStat> stat(uint64_t inode) override;
Result<FileStat> stat(uint64_t inode) override;
ox::Result<FileStat> stat(const char *path) override;
Result<FileStat> stat(const char *path) override;
uint64_t spaceNeeded(uint64_t size) override;
@ -74,7 +74,7 @@ class PassThroughFS: public FileSystem {
char *buff() override;
ox::Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) override;
Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) override;
bool valid() const override;
@ -87,7 +87,7 @@ class PassThroughFS: public FileSystem {
};
template<typename F>
ox::Error PassThroughFS::ls(const char *dir, F cb) {
Error PassThroughFS::ls(const char *dir, F cb) {
for (auto &p : std::filesystem::directory_iterator(m_path / stripSlash(dir))) {
auto u8p = p.path().filename().u8string();
oxReturnError(cb(u8p.c_str(), 0));

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

@ -143,7 +143,7 @@ class TypeDescWriter {
// array handler
template<typename T>
ox::Error TypeDescWriter::field(const char *name, T *val, std::size_t) {
Error TypeDescWriter::field(const char *name, T *val, std::size_t) {
if (m_type) {
constexpr typename ox::remove_pointer<decltype(val)>::type *p = nullptr;
bool alreadyExisted = false;
@ -159,7 +159,7 @@ ox::Error TypeDescWriter::field(const char *name, T *val, std::size_t) {
}
template<typename T>
ox::Error TypeDescWriter::field(const char *name, T val) {
Error TypeDescWriter::field(const char *name, T val) {
if (m_type) {
bool alreadyExisted = false;
const auto t = type(val, &alreadyExisted);
@ -171,7 +171,7 @@ ox::Error TypeDescWriter::field(const char *name, T val) {
}
template<typename T>
ox::Error TypeDescWriter::field(const char *name, T *val) {
Error TypeDescWriter::field(const char *name, T *val) {
if (m_type) {
bool alreadyExisted = false;
const auto t = type(val, &alreadyExisted);

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

@ -39,7 +39,7 @@ Error modelWriteDefinition(T*, O*) {
template<typename T, typename O>
Error model(T *io, O *obj) {
ox::Error err;
Error err;
if constexpr(ox_strcmp(T::opType(), ox::OpType::Read) == 0) {
err = modelRead(io, obj);
} else if constexpr(ox_strcmp(T::opType(), ox::OpType::Write) == 0) {

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

@ -17,7 +17,7 @@ namespace ox {
template<typename Reader, typename T>
class DataWalker {
template<typename ReaderBase, typename FH>
friend ox::Error parseField(const DescriptorField &field, ReaderBase *rdr, DataWalker<ReaderBase, FH> *walker);
friend Error parseField(const DescriptorField &field, ReaderBase *rdr, DataWalker<ReaderBase, FH> *walker);
private:
Vector<const DescriptorType*> m_typeStack;
@ -54,7 +54,7 @@ const DescriptorType *DataWalker<Reader, T>::type() const noexcept {
}
template<typename Reader, typename T>
ox::Error DataWalker<Reader, T>::read(const DescriptorField &f, Reader *rdr) {
Error DataWalker<Reader, T>::read(const DescriptorField &f, Reader *rdr) {
// get const ref of paths
const auto &pathCr = m_path;
const auto &typePathCr = m_typePath;
@ -82,7 +82,7 @@ void DataWalker<Reader, T>::popType() {
}
template<typename Reader, typename FH>
static ox::Error parseField(const DescriptorField &field, Reader *rdr, DataWalker<Reader, FH> *walker) {
static Error parseField(const DescriptorField &field, Reader *rdr, DataWalker<Reader, FH> *walker) {
walker->pushNamePath(field.fieldName);
if (field.subscriptLevels) {
// add array handling
@ -131,7 +131,7 @@ static ox::Error parseField(const DescriptorField &field, Reader *rdr, DataWalke
}
template<typename Reader, typename FH>
ox::Error model(Reader *rdr, DataWalker<Reader, FH> *walker) {
Error model(Reader *rdr, DataWalker<Reader, FH> *walker) {
auto type = walker->type();
if (!type) {
return OxError(1);
@ -146,7 +146,7 @@ ox::Error model(Reader *rdr, DataWalker<Reader, FH> *walker) {
}
template<typename Reader, typename Handler>
ox::Error walkModel(DescriptorType *type, uint8_t *data, std::size_t dataLen, Handler handler) {
Error walkModel(DescriptorType *type, uint8_t *data, std::size_t dataLen, Handler handler) {
DataWalker<Reader, Handler> walker(type, handler);
Reader rdr(data, dataLen);
return model(&rdr, &walker);

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

@ -393,7 +393,7 @@ size_t NodeBuffer<size_t, Item>::spaceNeeded(size_t size) {
template<typename size_t, typename Item>
template<typename F>
ox::Error NodeBuffer<size_t, Item>::compact(F cb) {
Error NodeBuffer<size_t, Item>::compact(F cb) {
auto src = firstItem();
auto dest = ptr(sizeof(*this));
while (dest.offset() <= src.offset()) {

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

@ -49,7 +49,7 @@ struct [[nodiscard]] Error {
};
constexpr Error _error(const char *file, uint32_t line, uint64_t errCode, const char *msg = nullptr) {
auto err = static_cast<ox::Error>(errCode);
auto err = static_cast<Error>(errCode);
err.file = file;
err.line = line;
err.msg = msg;
@ -92,12 +92,12 @@ struct [[nodiscard]] Result {
namespace error {
constexpr Error toError(ox::Error e) noexcept {
constexpr Error toError(Error e) noexcept {
return e;
}
template<typename T>
constexpr Error toError(const ox::Result<T> &ve) noexcept {
constexpr Error toError(const Result<T> &ve) noexcept {
return ve.error;
}