drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 6 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;
};
}

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

@ -10,10 +10,18 @@
#include <ox/ptrarith/nodebuffer.hpp>
#include "filestore.hpp"
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>
struct __attribute__((packed)) FileStoreItem: public ptrarith::Item<size_t> {
ox::LittleEndian<size_t> id = 0;
@ -43,7 +51,10 @@ struct __attribute__((packed)) FileStoreItem: public ptrarith::Item<size_t> {
template<typename size_t>
class FileStoreTemplate: public FileStore {
class FileStoreTemplate {
public:
using InodeId_t = size_t;
private:
using Item = FileStoreItem<size_t>;
@ -51,6 +62,7 @@ class FileStoreTemplate: public FileStore {
using Buffer = ptrarith::NodeBuffer<size_t, FileStoreItem<size_t>>;
static constexpr InodeId_t ReservedInodeEnd = 100;
static constexpr auto MaxInode = MaxValue<size_t> / 2;
struct __attribute__((packed)) FileStoreData {
ox::LittleEndian<size_t> rootNode = 0;
@ -63,23 +75,23 @@ class FileStoreTemplate: public FileStore {
public:
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
@ -93,24 +105,26 @@ class FileStoreTemplate: public FileStore {
*/
template<typename T>
Error read(InodeId_t id, FsSize_t readStart,
FsSize_t readSize, T *data,
FsSize_t *size);
FsSize_t readSize, T *data,
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:
void compact();
@ -165,8 +179,6 @@ class FileStoreTemplate: public FileStore {
bool canWrite(ItemPtr existing, size_t size);
bool valid() const;
};
template<typename size_t>
@ -388,7 +400,7 @@ Error FileStoreTemplate<size_t>::resize(std::size_t size, void *newBuff) {
}
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);
if (inode.valid()) {
return ValErr<StatInfo>({
@ -402,17 +414,17 @@ ValErr<typename FileStoreTemplate<size_t>::StatInfo> FileStoreTemplate<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);
}
template<typename size_t>
InodeId_t FileStoreTemplate<size_t>::size() {
typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::size() {
return m_buffer->size();
}
template<typename size_t>
InodeId_t FileStoreTemplate<size_t>::available() {
typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::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>
ValErr<InodeId_t> FileStoreTemplate<size_t>::generateInodeId() {
ValErr<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>::generateInodeId() {
auto fsData = fileStoreData();
if (fsData) {
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 {
template class Directory<uint16_t>;
template class Directory<uint32_t>;
template class Directory<FileStore16, uint16_t>;
template class Directory<FileStore32, uint32_t>;
template struct DirectoryEntry<uint16_t>;
template struct DirectoryEntry<uint32_t>;

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

@ -9,7 +9,7 @@
#pragma once
#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/std/std.hpp>
@ -83,7 +83,7 @@ struct __attribute__((packed)) DirectoryEntry {
};
template<typename InodeId_t>
template<typename FileStore, typename InodeId_t>
class Directory {
private:
@ -112,12 +112,12 @@ class Directory {
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>
Directory<InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
template<typename FileStore, typename InodeId_t>
Directory<FileStore, InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
m_fs = fs;
m_inodeId = inodeId;
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>
Error Directory<InodeId_t>::init() noexcept {
template<typename FileStore, typename InodeId_t>
Error Directory<FileStore, InodeId_t>::init() noexcept {
constexpr auto Size = sizeof(Buffer);
oxReturnError(m_fs->write(m_inodeId, nullptr, Size));
auto buff = m_fs->read(m_inodeId);
@ -140,8 +140,8 @@ Error Directory<InodeId_t>::init() noexcept {
return OxError(1);
}
template<typename InodeId_t>
Error Directory<InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
template<typename FileStore, typename InodeId_t>
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
@ -164,7 +164,7 @@ Error Directory<InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nam
oxReturnError(childInode.error);
// initialize the directory
Directory<InodeId_t> child(m_fs, childInode);
Directory<FileStore, InodeId_t> child(m_fs, childInode);
oxReturnError(child.init());
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()) {
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);
}
template<typename InodeId_t>
Error Directory<InodeId_t>::write(PathIterator path, InodeId_t inode, bool parents, FileName *nameBuff) noexcept {
template<typename FileStore, typename InodeId_t>
Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode, bool parents, FileName *nameBuff) noexcept {
InodeId_t nextChild = 0;
// 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);
}
template<typename InodeId_t>
Error Directory<InodeId_t>::remove(PathIterator path, FileName *nameBuff) noexcept {
template<typename FileStore, typename InodeId_t>
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)));
@ -284,8 +284,8 @@ Error Directory<InodeId_t>::remove(PathIterator path, FileName *nameBuff) noexce
return OxError(0);
}
template<typename InodeId_t>
ValErr<ox::fs::InodeId_t> Directory<InodeId_t>::find(const FileName &name) const noexcept {
template<typename FileStore, typename InodeId_t>
ValErr<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::find(const FileName &name) const noexcept {
oxTrace("ox::fs::Directory::find") << name.c_str();
auto buff = m_fs->read(m_inodeId).template to<Buffer>();
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<uint32_t>;
extern template class Directory<FileStore16, uint16_t>;
extern template class Directory<FileStore32, uint32_t>;
extern template struct DirectoryEntry<uint16_t>;
extern template struct DirectoryEntry<uint32_t>;
using Directory16 = Directory<uint16_t>;
using Directory32 = Directory<uint32_t>;
using Directory16 = Directory<FileStore16, uint16_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 {
template class Directory<uint16_t>;
template class Directory<uint32_t>;
template class FileSystemTemplate<uint16_t, Directory<uint16_t>>;
template class FileSystemTemplate<uint32_t, Directory<uint32_t>>;
template class FileSystemTemplate<FileStore16, Directory16>;
template class FileSystemTemplate<FileStore32, Directory32>;
}

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

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

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

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