[ox] Cleanup unnecessary ox::

deps/ox/src/ox/claw/write.hpp

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

deps/ox/src/ox/fs/filestore/filestoretemplate.hpp

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

deps/ox/src/ox/fs/filesystem/directory.hpp

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

deps/ox/src/ox/fs/filesystem/filelocation.hpp

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

deps/ox/src/ox/fs/filesystem/filesystem.cpp

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

deps/ox/src/ox/fs/filesystem/filesystem.hpp

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

deps/ox/src/ox/fs/filesystem/passthroughfs.cpp

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

deps/ox/src/ox/fs/filesystem/passthroughfs.hpp

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

deps/ox/src/ox/model/descwrite.hpp

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

deps/ox/src/ox/model/optype.hpp

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

deps/ox/src/ox/model/walk.hpp

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

deps/ox/src/ox/ptrarith/nodebuffer.hpp

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

deps/ox/src/ox/std/error.hpp

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