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

[ox/fs] Remove abstract FileStore class

Browse Source
This commit is contained in:
Gary Talent 2018-09-01 21:53:50 -05:00
parent 6648d941c9
commit 1770c8a1e2
7 changed files with 193 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,74 +0,0 @@
/*
* Copyright 2015 - 2018 gtalent2@gmail.com
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#pragma once
#include <ox/ptrarith/nodebuffer.hpp>
namespace ox::fs {
using InodeId_t = uint64_t;
using FsSize_t = std::size_t;
class FileStore {
public:
struct StatInfo {
InodeId_t inode = 0;
InodeId_t links = 0;
FsSize_t size = 0;
uint8_t fileType = 0;
};
virtual Error format() = 0;
virtual Error setSize(InodeId_t size) = 0;
virtual Error incLinks(InodeId_t id) = 0;
virtual Error decLinks(InodeId_t id) = 0;
virtual Error write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType = 0) = 0;
/**
* @return error if the inode could not be removed or did not exist
*/
virtual Error remove(InodeId_t id) = 0;
virtual Error read(InodeId_t id, void *data, FsSize_t dataSize, std::size_t *size = nullptr) = 0;
virtual Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) = 0;
/**
* @return data section of the requested file
*/
virtual const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id) = 0;
virtual ValErr<StatInfo> stat(InodeId_t id) = 0;
virtual Error resize(std::size_t size, void *newBuff = nullptr) = 0;
virtual InodeId_t spaceNeeded(FsSize_t size) = 0;
virtual InodeId_t size() = 0;
virtual InodeId_t available() = 0;
/**
* @return a pointer to the buffer of the file system, or null if not
* applicable
*/
virtual uint8_t *buff() = 0;
virtual Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) = 0;
virtual ValErr<InodeId_t> generateInodeId() = 0;
};
}

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

@ -10,10 +10,18 @@
#include <ox/ptrarith/nodebuffer.hpp> #include <ox/ptrarith/nodebuffer.hpp>
#include "filestore.hpp"
namespace ox::fs { namespace ox::fs {
using InodeId_t = uint64_t;
using FsSize_t = std::size_t;
struct StatInfo {
InodeId_t inode = 0;
InodeId_t links = 0;
FsSize_t size = 0;
uint8_t fileType = 0;
};
template<typename size_t> template<typename size_t>
struct __attribute__((packed)) FileStoreItem: public ptrarith::Item<size_t> { struct __attribute__((packed)) FileStoreItem: public ptrarith::Item<size_t> {
ox::LittleEndian<size_t> id = 0; ox::LittleEndian<size_t> id = 0;
@ -43,7 +51,10 @@ struct __attribute__((packed)) FileStoreItem: public ptrarith::Item<size_t> {
template<typename size_t> template<typename size_t>
class FileStoreTemplate: public FileStore { class FileStoreTemplate {
public:
using InodeId_t = size_t;
private: private:
using Item = FileStoreItem<size_t>; using Item = FileStoreItem<size_t>;
@ -51,6 +62,7 @@ class FileStoreTemplate: public FileStore {
using Buffer = ptrarith::NodeBuffer<size_t, FileStoreItem<size_t>>; using Buffer = ptrarith::NodeBuffer<size_t, FileStoreItem<size_t>>;
static constexpr InodeId_t ReservedInodeEnd = 100; static constexpr InodeId_t ReservedInodeEnd = 100;
static constexpr auto MaxInode = MaxValue<size_t> / 2;
struct __attribute__((packed)) FileStoreData { struct __attribute__((packed)) FileStoreData {
ox::LittleEndian<size_t> rootNode = 0; ox::LittleEndian<size_t> rootNode = 0;
@ -63,23 +75,23 @@ class FileStoreTemplate: public FileStore {
public: public:
FileStoreTemplate(void *buff, size_t buffSize); FileStoreTemplate(void *buff, size_t buffSize);
Error format() override; Error format();
Error setSize(InodeId_t buffSize) override; Error setSize(InodeId_t buffSize);
Error incLinks(InodeId_t id) override; Error incLinks(InodeId_t id);
Error decLinks(InodeId_t id) override; Error decLinks(InodeId_t id);
Error write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType = 0) override; Error write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType = 0);
Error remove(InodeId_t id) override; Error remove(InodeId_t id);
Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size) override; Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr);
Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size) override; Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr);
const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id) override; const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id);
/** /**
* Reads the "file" at the given id. You are responsible for freeing * Reads the "file" at the given id. You are responsible for freeing
@ -96,21 +108,23 @@ class FileStoreTemplate: public FileStore {
FsSize_t readSize, T *data, FsSize_t readSize, T *data,
FsSize_t *size); FsSize_t *size);
ValErr<StatInfo> stat(InodeId_t id) override; ValErr<StatInfo> stat(InodeId_t id);
Error resize(std::size_t size, void *newBuff = nullptr) override; Error resize(std::size_t size, void *newBuff = nullptr);
InodeId_t spaceNeeded(FsSize_t size) override; InodeId_t spaceNeeded(FsSize_t size);
InodeId_t size() override; InodeId_t size();
InodeId_t available() override; InodeId_t available();
uint8_t *buff() override; uint8_t *buff();
Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) override; Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t));
ValErr<InodeId_t> generateInodeId() override; ValErr<InodeId_t> generateInodeId();
bool valid() const;
private: private:
void compact(); void compact();
@ -165,8 +179,6 @@ class FileStoreTemplate: public FileStore {
bool canWrite(ItemPtr existing, size_t size); bool canWrite(ItemPtr existing, size_t size);
bool valid() const;
}; };
template<typename size_t> template<typename size_t>
@ -388,7 +400,7 @@ Error FileStoreTemplate<size_t>::resize(std::size_t size, void *newBuff) {
} }
template<typename size_t> template<typename size_t>
ValErr<typename FileStoreTemplate<size_t>::StatInfo> FileStoreTemplate<size_t>::stat(InodeId_t id) { ValErr<StatInfo> FileStoreTemplate<size_t>::stat(InodeId_t id) {
auto inode = find(id); auto inode = find(id);
if (inode.valid()) { if (inode.valid()) {
return ValErr<StatInfo>({ return ValErr<StatInfo>({
@ -402,17 +414,17 @@ ValErr<typename FileStoreTemplate<size_t>::StatInfo> FileStoreTemplate<size_t>::
} }
template<typename size_t> template<typename size_t>
InodeId_t FileStoreTemplate<size_t>::spaceNeeded(FsSize_t size) { typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::spaceNeeded(FsSize_t size) {
return m_buffer->spaceNeeded(size); return m_buffer->spaceNeeded(size);
} }
template<typename size_t> template<typename size_t>
InodeId_t FileStoreTemplate<size_t>::size() { typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::size() {
return m_buffer->size(); return m_buffer->size();
} }
template<typename size_t> template<typename size_t>
InodeId_t FileStoreTemplate<size_t>::available() { typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::available() {
return m_buffer->available(); return m_buffer->available();
} }
@ -430,7 +442,7 @@ Error FileStoreTemplate<size_t>::walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) {
} }
template<typename size_t> template<typename size_t>
ValErr<InodeId_t> FileStoreTemplate<size_t>::generateInodeId() { ValErr<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>::generateInodeId() {
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData) { if (fsData) {
for (auto i = 0; i < 100; i++) { for (auto i = 0; i < 100; i++) {

4
deps/ox/src/ox/fs/filesystem2/directory.cpp vendored
View File

@ -10,8 +10,8 @@
namespace ox::fs { namespace ox::fs {
template class Directory<uint16_t>; template class Directory<FileStore16, uint16_t>;
template class Directory<uint32_t>; template class Directory<FileStore32, uint32_t>;
template struct DirectoryEntry<uint16_t>; template struct DirectoryEntry<uint16_t>;
template struct DirectoryEntry<uint32_t>; template struct DirectoryEntry<uint32_t>;

42
deps/ox/src/ox/fs/filesystem2/directory.hpp vendored
View File

@ -9,7 +9,7 @@
#pragma once #pragma once
#include <ox/fs/filesystem/pathiterator.hpp> #include <ox/fs/filesystem/pathiterator.hpp>
#include <ox/fs/filestore/filestore.hpp> #include <ox/fs/filestore/filestoretemplate.hpp>
#include <ox/ptrarith/nodebuffer.hpp> #include <ox/ptrarith/nodebuffer.hpp>
#include <ox/std/std.hpp> #include <ox/std/std.hpp>
@ -83,7 +83,7 @@ struct __attribute__((packed)) DirectoryEntry {
}; };
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
class Directory { class Directory {
private: private:
@ -112,12 +112,12 @@ class Directory {
Error remove(PathIterator it, FileName *nameBuff = nullptr) noexcept; Error remove(PathIterator it, FileName *nameBuff = nullptr) noexcept;
ValErr<ox::fs::InodeId_t> find(const FileName &name) const noexcept; ValErr<typename FileStore::InodeId_t> find(const FileName &name) const noexcept;
}; };
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
Directory<InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) { Directory<FileStore, InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
m_fs = fs; m_fs = fs;
m_inodeId = inodeId; m_inodeId = inodeId;
auto buff = fs->read(inodeId).template to<Buffer>(); auto buff = fs->read(inodeId).template to<Buffer>();
@ -126,8 +126,8 @@ Directory<InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
} }
} }
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
Error Directory<InodeId_t>::init() noexcept { Error Directory<FileStore, InodeId_t>::init() noexcept {
constexpr auto Size = sizeof(Buffer); constexpr auto Size = sizeof(Buffer);
oxReturnError(m_fs->write(m_inodeId, nullptr, Size)); oxReturnError(m_fs->write(m_inodeId, nullptr, Size));
auto buff = m_fs->read(m_inodeId); auto buff = m_fs->read(m_inodeId);
@ -140,8 +140,8 @@ Error Directory<InodeId_t>::init() noexcept {
return OxError(1); return OxError(1);
} }
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
Error Directory<InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) { Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
if (path.valid()) { if (path.valid()) {
oxTrace("ox::fs::Directory::mkdir") << path.fullPath(); oxTrace("ox::fs::Directory::mkdir") << path.fullPath();
// reuse nameBuff if it has already been allocated, as it is a rather large variable // reuse nameBuff if it has already been allocated, as it is a rather large variable
@ -164,7 +164,7 @@ Error Directory<InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nam
oxReturnError(childInode.error); oxReturnError(childInode.error);
// initialize the directory // initialize the directory
Directory<InodeId_t> child(m_fs, childInode); Directory<FileStore, InodeId_t> child(m_fs, childInode);
oxReturnError(child.init()); oxReturnError(child.init());
auto err = write(name->c_str(), childInode, false); auto err = write(name->c_str(), childInode, false);
@ -176,7 +176,7 @@ Error Directory<InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nam
} }
} }
Directory<InodeId_t> child(m_fs, childInode); Directory<FileStore, InodeId_t> child(m_fs, childInode);
if (path.hasNext()) { if (path.hasNext()) {
oxReturnError(child.mkdir(path + 1, parents, nameBuff)); oxReturnError(child.mkdir(path + 1, parents, nameBuff));
} }
@ -184,8 +184,8 @@ Error Directory<InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nam
return OxError(0); return OxError(0);
} }
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
Error Directory<InodeId_t>::write(PathIterator path, InodeId_t inode, bool parents, FileName *nameBuff) noexcept { Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode, bool parents, FileName *nameBuff) noexcept {
InodeId_t nextChild = 0; InodeId_t nextChild = 0;
// reuse nameBuff if it has already been allocated, as it is a rather large variable // reuse nameBuff if it has already been allocated, as it is a rather large variable
@ -254,8 +254,8 @@ Error Directory<InodeId_t>::write(PathIterator path, InodeId_t inode, bool paren
return OxError(1); return OxError(1);
} }
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
Error Directory<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 // reuse nameBuff if it has already been allocated, as it is a rather large variable
if (nameBuff == nullptr) { if (nameBuff == nullptr) {
nameBuff = reinterpret_cast<FileName*>(ox_alloca(sizeof(FileName))); nameBuff = reinterpret_cast<FileName*>(ox_alloca(sizeof(FileName)));
@ -284,8 +284,8 @@ Error Directory<InodeId_t>::remove(PathIterator path, FileName *nameBuff) noexce
return OxError(0); return OxError(0);
} }
template<typename InodeId_t> template<typename FileStore, typename InodeId_t>
ValErr<ox::fs::InodeId_t> Directory<InodeId_t>::find(const FileName &name) const noexcept { ValErr<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::find(const FileName &name) const noexcept {
oxTrace("ox::fs::Directory::find") << name.c_str(); oxTrace("ox::fs::Directory::find") << name.c_str();
auto buff = m_fs->read(m_inodeId).template to<Buffer>(); auto buff = m_fs->read(m_inodeId).template to<Buffer>();
if (buff.valid()) { if (buff.valid()) {
@ -308,13 +308,13 @@ ValErr<ox::fs::InodeId_t> Directory<InodeId_t>::find(const FileName &name) const
} }
extern template class Directory<uint16_t>; extern template class Directory<FileStore16, uint16_t>;
extern template class Directory<uint32_t>; extern template class Directory<FileStore32, uint32_t>;
extern template struct DirectoryEntry<uint16_t>; extern template struct DirectoryEntry<uint16_t>;
extern template struct DirectoryEntry<uint32_t>; extern template struct DirectoryEntry<uint32_t>;
using Directory16 = Directory<uint16_t>; using Directory16 = Directory<FileStore16, uint16_t>;
using Directory32 = Directory<uint32_t>; using Directory32 = Directory<FileStore32, uint32_t>;
} }

7
deps/ox/src/ox/fs/filesystem2/filesystem.cpp vendored
View File

@ -10,10 +10,7 @@
namespace ox::fs { namespace ox::fs {
template class Directory<uint16_t>; template class FileSystemTemplate<FileStore16, Directory16>;
template class Directory<uint32_t>; template class FileSystemTemplate<FileStore32, Directory32>;
template class FileSystemTemplate<uint16_t, Directory<uint16_t>>;
template class FileSystemTemplate<uint32_t, Directory<uint32_t>>;
} }

216
deps/ox/src/ox/fs/filesystem2/filesystem.hpp vendored
View File

@ -15,19 +15,65 @@
namespace ox::fs { namespace ox::fs {
class FileSystem {
public:
virtual Error format() = 0;
virtual Error mkdir(const char *path, bool recursive = false) = 0;
/**
* Moves an entry from one directory to another.
* @param src the path to the file
* @param dest the path of the destination directory
*/
virtual Error move(const char *src, const char *dest) = 0;
virtual Error read(const char *path, void *buffer, std::size_t buffSize) = 0;
virtual Error read(uint64_t inode, void *buffer, std::size_t size) = 0;
virtual Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) = 0;
virtual Error remove(const char *path, bool recursive = false) = 0;
virtual void resize(uint64_t size, void *buffer = nullptr) = 0;
virtual Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) = 0;
virtual Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) = 0;
virtual ValErr<FileStat> stat(uint64_t inode) = 0;
virtual ValErr<FileStat> stat(const char *path) = 0;
virtual uint64_t spaceNeeded(uint64_t size) = 0;
virtual uint64_t available() = 0;
virtual uint64_t size() = 0;
virtual uint8_t *buff() = 0;
virtual Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) = 0;
virtual bool valid() const = 0;
};
/** /**
* FileSystemTemplate used to create file system that wraps around a FileStore, * FileSystemTemplate used to create file system that wraps around a FileStore,
* taking an inode size and a directory type as parameters. * taking an inode size and a directory type as parameters.
* *
* Note: Directory parameter must have a default constructor. * Note: Directory parameter must have a default constructor.
*/ */
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
class FileSystemTemplate { class FileSystemTemplate: public FileSystem {
private: private:
static constexpr InodeId_t InodeFsData = 2; static constexpr auto InodeFsData = 2;
struct __attribute__((packed)) FileSystemData { struct __attribute__((packed)) FileSystemData {
LittleEndian<InodeId_t> rootDirInode; LittleEndian<typename FileStore::InodeId_t> rootDirInode;
}; };
FileStore *m_fs = nullptr; FileStore *m_fs = nullptr;
@ -37,46 +83,41 @@ class FileSystemTemplate {
~FileSystemTemplate(); ~FileSystemTemplate();
Error format(); Error format() override;
Error mkdir(const char *path, bool recursive = false); Error mkdir(const char *path, bool recursive = false) override;
/** Error move(const char *src, const char *dest) override;
* Moves an entry from one directory to another.
* @param src the path to the file
* @param dest the path of the destination directory
*/
Error move(const char *src, const char *dest);
Error read(const char *path, void *buffer, std::size_t buffSize); Error read(const char *path, void *buffer, std::size_t buffSize) override;
Error read(uint64_t inode, void *buffer, std::size_t size); Error read(uint64_t inode, 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); Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
Error remove(const char *path, bool recursive = false); Error remove(const char *path, bool recursive = false) override;
void resize(uint64_t size, void *buffer = nullptr); void resize(uint64_t size, void *buffer = nullptr) override;
Error write(const char *path, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile); Error write(const char *path, 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); Error write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = FileType_NormalFile) override;
ValErr<FileStat> stat(uint64_t inode); ValErr<FileStat> stat(uint64_t inode) override;
ValErr<FileStat> stat(const char *path); ValErr<FileStat> stat(const char *path) override;
uint64_t spaceNeeded(uint64_t size); uint64_t spaceNeeded(uint64_t size) override;
uint64_t available(); uint64_t available() override;
uint64_t size(); uint64_t size() override;
uint8_t *buff(); uint8_t *buff() override;
Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)); Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) override;
bool valid() const; bool valid() const override;
private: private:
ValErr<FileSystemData> fileSystemData() const noexcept; ValErr<FileSystemData> fileSystemData() const noexcept;
@ -90,20 +131,20 @@ class FileSystemTemplate {
}; };
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
FileSystemTemplate<InodeId_t, Directory>::FileSystemTemplate(FileStore *fs) { FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(FileStore *fs) {
m_fs = fs; m_fs = fs;
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
FileSystemTemplate<InodeId_t, Directory>::~FileSystemTemplate() { FileSystemTemplate<FileStore, Directory>::~FileSystemTemplate() {
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, Directory>::format() { Error FileSystemTemplate<FileStore, Directory>::format() {
oxReturnError(m_fs->format()); oxReturnError(m_fs->format());
constexpr auto rootDirInode = MaxValue<InodeId_t> / 2; constexpr auto rootDirInode = MaxValue<typename FileStore::InodeId_t> / 2;
Directory rootDir(m_fs, rootDirInode); Directory rootDir(m_fs, rootDirInode);
oxReturnError(rootDir.init()); oxReturnError(rootDir.init());
@ -119,21 +160,16 @@ Error FileSystemTemplate<InodeId_t, Directory>::format() {
return OxError(0); return OxError(0);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, Directory>::mkdir(const char *path, bool recursive) { Error FileSystemTemplate<FileStore, Directory>::mkdir(const char *path, bool recursive) {
auto fd = fileSystemData(); oxTrace("ox::fs::FileSystemTemplate::mkdir") << "path:" << path << "recursive:" << recursive;
if (fd.ok()) { auto rootDir = this->rootDir();
oxTrace("ox::fs::FileSystemTemplate::mkdir") << "rootDirInode:" << fd.value.rootDirInode; oxReturnError(rootDir.error);
Directory rootDir(m_fs, fd.value.rootDirInode); return rootDir.value.mkdir(path, recursive);
return rootDir.mkdir(path, recursive);
} else {
oxLogError(fd.error);
return fd.error;
}
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, Directory>::move(const char *src, const char *dest) { Error FileSystemTemplate<FileStore, Directory>::move(const char *src, const char *dest) {
auto fd = fileSystemData(); auto fd = fileSystemData();
oxReturnError(fd.error); oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode); Directory rootDir(m_fs, fd.value.rootDirInode);
@ -144,8 +180,8 @@ Error FileSystemTemplate<InodeId_t, Directory>::move(const char *src, const char
return OxError(0); return OxError(0);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, 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(); auto fd = fileSystemData();
oxReturnError(fd.error); oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode); Directory rootDir(m_fs, fd.value.rootDirInode);
@ -154,18 +190,18 @@ Error FileSystemTemplate<InodeId_t, Directory>::read(const char *path, void *buf
return read(inode, buffer, buffSize); return read(inode, buffer, buffSize);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, 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); return m_fs->read(inode, buffer, buffSize);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, 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, buffer, size); return m_fs->read(inode, readStart, readSize, buffer, size);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, Directory>::remove(const char *path, bool recursive) { Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool recursive) {
auto fd = fileSystemData(); auto fd = fileSystemData();
oxReturnError(fd.error); oxReturnError(fd.error);
Directory rootDir(m_fs, fd.value.rootDirInode); Directory rootDir(m_fs, fd.value.rootDirInode);
@ -186,16 +222,16 @@ Error FileSystemTemplate<InodeId_t, Directory>::remove(const char *path, bool re
return OxError(0); return OxError(0);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
void FileSystemTemplate<InodeId_t, Directory>::resize(uint64_t size, void *buffer) { void FileSystemTemplate<FileStore, Directory>::resize(uint64_t size, void *buffer) {
m_fs->resize(size, buffer); m_fs->resize(size, buffer);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, 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 = find(path); auto inode = find(path);
if (inode.error) { if (inode.error) {
inode = m_fs->generateInodeId(); inode.value = m_fs->generateInodeId();
} }
auto rootDir = this->rootDir(); auto rootDir = this->rootDir();
oxReturnError(rootDir.error); oxReturnError(rootDir.error);
@ -204,13 +240,13 @@ Error FileSystemTemplate<InodeId_t, Directory>::write(const char *path, void *bu
return 0; return 0;
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, 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); return m_fs->write(inode, buffer, size, fileType);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
ValErr<FileStat> FileSystemTemplate<InodeId_t, Directory>::stat(uint64_t inode) { ValErr<FileStat> FileSystemTemplate<FileStore, Directory>::stat(uint64_t inode) {
auto s = m_fs->stat(inode); auto s = m_fs->stat(inode);
FileStat out; FileStat out;
out.inode = s.value.inode; out.inode = s.value.inode;
@ -220,8 +256,8 @@ ValErr<FileStat> FileSystemTemplate<InodeId_t, Directory>::stat(uint64_t inode)
return {out, s.error}; return {out, s.error};
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
ValErr<FileStat> FileSystemTemplate<InodeId_t, Directory>::stat(const char *path) { ValErr<FileStat> FileSystemTemplate<FileStore, Directory>::stat(const char *path) {
auto inode = find(path); auto inode = find(path);
if (inode.error) { if (inode.error) {
return {{}, inode.error}; return {{}, inode.error};
@ -229,33 +265,38 @@ ValErr<FileStat> FileSystemTemplate<InodeId_t, Directory>::stat(const char *path
return stat(inode.value); return stat(inode.value);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<InodeId_t, Directory>::spaceNeeded(uint64_t size) { uint64_t FileSystemTemplate<FileStore, Directory>::spaceNeeded(uint64_t size) {
return m_fs->spaceNeeded(size); return m_fs->spaceNeeded(size);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<InodeId_t, Directory>::available() { uint64_t FileSystemTemplate<FileStore, Directory>::available() {
return m_fs->available(); return m_fs->available();
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<InodeId_t, Directory>::size() { uint64_t FileSystemTemplate<FileStore, Directory>::size() {
return m_fs->size(); return m_fs->size();
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
uint8_t *FileSystemTemplate<InodeId_t, Directory>::buff() { uint8_t *FileSystemTemplate<FileStore, Directory>::buff() {
return m_fs->buff(); return m_fs->buff();
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
Error FileSystemTemplate<InodeId_t, Directory>::walk(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); return m_fs->walk(cb);
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
ValErr<typename FileSystemTemplate<InodeId_t, Directory>::FileSystemData> FileSystemTemplate<InodeId_t, Directory>::fileSystemData() const noexcept { bool FileSystemTemplate<FileStore, Directory>::valid() const {
return m_fs && m_fs->valid();
}
template<typename FileStore, typename Directory>
ValErr<typename FileSystemTemplate<FileStore, Directory>::FileSystemData> FileSystemTemplate<FileStore, Directory>::fileSystemData() const noexcept {
FileSystemData fd; FileSystemData fd;
auto err = m_fs->read(InodeFsData, &fd, sizeof(fd)); auto err = m_fs->read(InodeFsData, &fd, sizeof(fd));
if (err != 0) { if (err != 0) {
@ -264,8 +305,8 @@ ValErr<typename FileSystemTemplate<InodeId_t, Directory>::FileSystemData> FileSy
return fd; return fd;
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
ValErr<uint64_t> FileSystemTemplate<InodeId_t, Directory>::find(const char *path) const noexcept { ValErr<uint64_t> FileSystemTemplate<FileStore, Directory>::find(const char *path) const noexcept {
auto fd = fileSystemData(); auto fd = fileSystemData();
if (fd.error) { if (fd.error) {
return {0, fd.error}; return {0, fd.error};
@ -278,8 +319,8 @@ ValErr<uint64_t> FileSystemTemplate<InodeId_t, Directory>::find(const char *path
return inode.value; return inode.value;
} }
template<typename InodeId_t, typename Directory> template<typename FileStore, typename Directory>
ValErr<Directory> FileSystemTemplate<InodeId_t, Directory>::rootDir() const noexcept { ValErr<Directory> FileSystemTemplate<FileStore, Directory>::rootDir() const noexcept {
auto fd = fileSystemData(); auto fd = fileSystemData();
if (fd.error) { if (fd.error) {
return {{}, fd.error}; return {{}, fd.error};
@ -287,13 +328,10 @@ ValErr<Directory> FileSystemTemplate<InodeId_t, Directory>::rootDir() const noex
return Directory(m_fs, fd.value.rootDirInode); return Directory(m_fs, fd.value.rootDirInode);
} }
extern template class Directory<uint16_t>; extern template class FileSystemTemplate<FileStore16, Directory16>;
extern template class Directory<uint32_t>; extern template class FileSystemTemplate<FileStore32, Directory32>;
extern template class FileSystemTemplate<uint16_t, Directory<uint16_t>>; using FileSystem16 = FileSystemTemplate<FileStore16, Directory16>;
extern template class FileSystemTemplate<uint32_t, Directory<uint16_t>>; using FileSystem32 = FileSystemTemplate<FileStore32, Directory32>;
using FileSystem16 = FileSystemTemplate<uint16_t, Directory<uint16_t>>;
using FileSystem32 = FileSystemTemplate<uint32_t, Directory<uint32_t>>;
} }

1
deps/ox/src/ox/fs/test/tests.cpp vendored
View File

@ -17,7 +17,6 @@
#include <string> #include <string>
#include <ox/fs/fs.hpp> #include <ox/fs/fs.hpp>
#include <ox/std/std.hpp> #include <ox/std/std.hpp>
#include <ox/fs/filestore/filestore.hpp>
#include <ox/fs/filestore/filestoretemplate.hpp> #include <ox/fs/filestore/filestoretemplate.hpp>
#include <ox/fs/filesystem2/filesystem.hpp> #include <ox/fs/filesystem2/filesystem.hpp>