drinkingtea/nostalgia
2
0
Fork 0
Code Issues 4 Pull Requests Actions Releases 13 Activity

[ox/fs] Make format method static

Browse Source
This commit is contained in:
Gary Talent
2018-12-29 22:29:03 -06:00
parent 713aa7380f
commit 55119253da
14 changed files with 172 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -8,7 +8,7 @@
#include "directory.hpp"
namespace ox::fs {
namespace ox {
template class Directory<FileStore16, uint16_t>;
template class Directory<FileStore32, uint32_t>;

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

@@ -13,7 +13,7 @@
#include <ox/ptrarith/nodebuffer.hpp>
#include <ox/std/std.hpp>
namespace ox::fs {
namespace ox {
template<typename InodeId_t>
struct __attribute__((packed)) DirectoryEntry {
@@ -91,12 +91,12 @@ class Directory {
InodeId_t m_inodeId = 0;
std::size_t m_size = 0;
FileStore *m_fs = nullptr;
FileStore m_fs;
public:
Directory() = default;
Directory(FileStore *fs, InodeId_t inode);
Directory(FileStore fs, InodeId_t inode);
/**
* Initializes Directory.
@@ -112,6 +112,9 @@ class Directory {
Error remove(PathIterator it, FileName *nameBuff = nullptr) noexcept;
template<typename F>
Error ls(F cb) noexcept;
ValErr<typename FileStore::InodeId_t> findEntry(const FileName &name) const noexcept;
ValErr<typename FileStore::InodeId_t> find(PathIterator name, FileName *nameBuff = nullptr) const noexcept;
@@ -119,10 +122,10 @@ class Directory {
};
template<typename FileStore, typename InodeId_t>
Directory<FileStore, InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
Directory<FileStore, InodeId_t>::Directory(FileStore fs, InodeId_t inodeId) {
m_fs = fs;
m_inodeId = inodeId;
auto buff = fs->read(inodeId).template to<Buffer>();
auto buff = m_fs.read(inodeId).template to<Buffer>();
if (buff.valid()) {
m_size = buff.size();
}
@@ -131,8 +134,8 @@ Directory<FileStore, InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
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);
oxReturnError(m_fs.write(m_inodeId, nullptr, Size));
auto buff = m_fs.read(m_inodeId);
if (buff.valid()) {
new (buff) Buffer(Size);
m_size = Size;
@@ -161,7 +164,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
if (!parents && path.hasNext()) {
return OxError(1);
}
childInode = m_fs->generateInodeId();
childInode = m_fs.generateInodeId();
oxLogError(childInode.error);
oxReturnError(childInode.error);
@@ -173,7 +176,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
if (err) {
oxLogError(err);
// could not index the directory, delete it
oxLogError(m_fs->remove(childInode));
oxLogError(m_fs.remove(childInode));
return err;
}
}
@@ -225,7 +228,7 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
// find existing version of directory
oxTrace("ox::fs::Directory::write") << "Searching for inode" << m_inodeId;
auto old = m_fs->read(m_inodeId);
auto old = m_fs.read(m_inodeId);
if (old.valid()) {
const auto entrySize = DirectoryEntry<InodeId_t>::spaceNeeded(name->len());
const auto entryDataSize =DirectoryEntry<InodeId_t>::DirectoryEntryData::spaceNeeded(name->len());
@@ -239,7 +242,7 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
if (val.valid()) {
oxTrace("ox::fs::Directory::write") << "Attempting to write Directory to FileStore";
val->init(inode, name->data(), entrySize);
return m_fs->write(m_inodeId, cpy, cpy->size());
return m_fs.write(m_inodeId, cpy, cpy->size());
} else {
oxTrace("ox::fs::Directory::write::fail") << "Could not allocate memory for new directory entry";
return OxError(1);
@@ -266,7 +269,7 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
oxReturnError(path.get(&name));
oxTrace("ox::fs::Directory::remove") << 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()) {
oxTrace("ox::fs::Directory::remove") << "Found directory buffer.";
for (auto i = buff->iterator(); i.valid(); i.next()) {
@@ -286,10 +289,33 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
return OxError(0);
}
template<typename FileStore, typename InodeId_t>
template<typename F>
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()) {
oxTrace("ox::fs::Directory::ls") << "Found directory buffer.";
for (auto i = buff->iterator(); i.valid(); i.next()) {
auto data = i->data();
if (data.valid()) {
oxReturnError(cb(data->name, data->inode));
} else {
oxTrace("ox::fs::Directory::ls") << "INVALID DIRECTORY ENTRY";
}
}
oxTrace("ox::fs::Directory::ls::fail");
return OxError(1);
} else {
oxTrace("ox::fs::Directory::ls::fail") << "Could not directory buffer";
return OxError(2);
}
}
template<typename FileStore, typename InodeId_t>
ValErr<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::findEntry(const FileName &name) const noexcept {
oxTrace("ox::fs::Directory::findEntry") << 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()) {
oxTrace("ox::fs::Directory::findEntry") << "Found directory buffer.";
for (auto i = buff->iterator(); i.valid(); i.next()) {

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

@@ -8,7 +8,7 @@
#include "filesystem.hpp"
namespace ox::fs {
namespace ox {
template class FileSystemTemplate<FileStore16, Directory16>;
template class FileSystemTemplate<FileStore32, Directory32>;

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

@@ -13,12 +13,12 @@
#include "directory.hpp"
namespace ox::fs {
namespace ox {
class FileSystem {
public:
virtual Error format() = 0;
virtual ~FileSystem() = default;
virtual Error mkdir(const char *path, bool recursive = false) = 0;
@@ -51,7 +51,7 @@ class FileSystem {
virtual uint64_t available() = 0;
virtual uint64_t size() = 0;
virtual uint64_t size() const = 0;
virtual uint8_t *buff() = 0;
@@ -76,14 +76,16 @@ class FileSystemTemplate: public FileSystem {
LittleEndian<typename FileStore::InodeId_t> rootDirInode;
};
FileStore *m_fs = nullptr;
FileStore m_fs;
public:
FileSystemTemplate(FileStore *fs);
FileSystemTemplate() = default;
FileSystemTemplate(FileStore fs);
~FileSystemTemplate();
Error format() override;
static Error format(void *buff, uint64_t buffSize);
Error mkdir(const char *path, bool recursive = false) override;
@@ -95,6 +97,9 @@ class FileSystemTemplate: public FileSystem {
Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
template<typename F>
Error ls(const char *dir, F cb);
Error remove(const char *path, bool recursive = false) override;
void resize(uint64_t size, void *buffer = nullptr) override;
@@ -111,7 +116,7 @@ class FileSystemTemplate: public FileSystem {
uint64_t available() override;
uint64_t size() override;
uint64_t size() const override;
uint8_t *buff() override;
@@ -132,7 +137,7 @@ class FileSystemTemplate: public FileSystem {
};
template<typename FileStore, typename Directory>
FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(FileStore *fs) {
FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(FileStore fs) {
m_fs = fs;
}
@@ -141,19 +146,20 @@ FileSystemTemplate<FileStore, Directory>::~FileSystemTemplate() {
}
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::format() {
oxReturnError(m_fs->format());
Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buffSize) {
oxReturnError(FileStore::format(buff, buffSize));
FileStore fs(buff, buffSize);
constexpr auto rootDirInode = MaxValue<typename FileStore::InodeId_t> / 2;
Directory rootDir(m_fs, rootDirInode);
Directory rootDir(fs, rootDirInode);
oxReturnError(rootDir.init());
FileSystemData fd;
fd.rootDirInode = rootDirInode;
oxTrace("ox::fs::FileSystemTemplate::format") << "rootDirInode:" << fd.rootDirInode;
oxReturnError(m_fs->write(InodeFsData, &fd, sizeof(fd)));
oxReturnError(fs.write(InodeFsData, &fd, sizeof(fd)));
if (m_fs->read(fd.rootDirInode).valid()) {
if (fs.read(fd.rootDirInode).valid()) {
oxTrace("ox::fs::FileSystemTemplate::format::error") << "FileSystemTemplate::format did not correctly create root directory";
}
@@ -192,12 +198,24 @@ Error FileSystemTemplate<FileStore, Directory>::read(const char *path, void *buf
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);
return m_fs.read(inode, buffer, buffSize);
}
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);
return m_fs.read(inode, readStart, readSize, reinterpret_cast<uint8_t*>(buffer), size);
}
template<typename FileStore, typename Directory>
template<typename F>
Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
auto s = stat(path);
oxReturnError(s.error);
Directory dir(m_fs, s.value.inode);
dir.ls(cb);
return OxError(0);
}
template<typename FileStore, typename Directory>
@@ -224,14 +242,14 @@ Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool re
template<typename FileStore, typename Directory>
void FileSystemTemplate<FileStore, Directory>::resize(uint64_t size, void *buffer) {
m_fs->resize(size, buffer);
m_fs.resize(size, buffer);
}
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.value = m_fs->generateInodeId();
inode.value = m_fs.generateInodeId();
}
auto rootDir = this->rootDir();
oxReturnError(rootDir.error);
@@ -242,12 +260,12 @@ Error FileSystemTemplate<FileStore, Directory>::write(const char *path, void *bu
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);
return m_fs.write(inode, buffer, size, fileType);
}
template<typename FileStore, typename Directory>
ValErr<FileStat> FileSystemTemplate<FileStore, Directory>::stat(uint64_t inode) {
auto s = m_fs->stat(inode);
auto s = m_fs.stat(inode);
FileStat out;
out.inode = s.value.inode;
out.links = s.value.links;
@@ -267,38 +285,38 @@ ValErr<FileStat> FileSystemTemplate<FileStore, Directory>::stat(const char *path
template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<FileStore, Directory>::spaceNeeded(uint64_t size) {
return m_fs->spaceNeeded(size);
return m_fs.spaceNeeded(size);
}
template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<FileStore, Directory>::available() {
return m_fs->available();
return m_fs.available();
}
template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<FileStore, Directory>::size() {
return m_fs->size();
uint64_t FileSystemTemplate<FileStore, Directory>::size() const {
return m_fs.size();
}
template<typename FileStore, typename Directory>
uint8_t *FileSystemTemplate<FileStore, Directory>::buff() {
return m_fs->buff();
return m_fs.buff();
}
template<typename FileStore, typename Directory>
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 FileStore, typename Directory>
bool FileSystemTemplate<FileStore, Directory>::valid() const {
return m_fs && m_fs->valid();
return 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));
auto err = m_fs.read(InodeFsData, &fd, sizeof(fd));
if (err != 0) {
return {fd, err};
}