1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/* -------------------------------------------
Copyright Mahrouss Logic
------------------------------------------- */
#include <KernelKit/FileManager.hpp>
#include <NewKit/ErrorID.hpp>
#include <NewKit/Utils.hpp>
/// BUGS: 0
//! @brief File manager for NewOS.
namespace NewOS {
static FilesystemManagerInterface* kMounted = nullptr;
/// @brief FilesystemManager getter.
/// @return The mounted filesystem.
FilesystemManagerInterface* FilesystemManagerInterface::GetMounted() {
return kMounted;
}
/// @brief Unmount filesystem.
/// @return The unmounted filesystem.
FilesystemManagerInterface* FilesystemManagerInterface::Unmount() {
if (kMounted) {
auto mount = kMounted;
kMounted = nullptr;
return mount;
}
return nullptr;
}
/// @brief Mount filesystem.
/// @param mountPtr The filesystem to mount.
/// @return if it succeeded true, otherwise false.
bool FilesystemManagerInterface::Mount(FilesystemManagerInterface* mountPtr) {
if (kMounted == nullptr) {
kMounted = mountPtr;
return true;
}
return false;
}
#ifdef __FSKIT_NEWFS__
/// @brief Opens a new file.
/// @param path
/// @param r
/// @return
NodePtr NewFilesystemManager::Open(const char* path, const char* r) {
if (!path || *path == 0) return nullptr;
if (!r || *r == 0) return nullptr;
auto catalog = fImpl->GetCatalog(path);
if (catalog->Kind != kNewFSCatalogKindFile) {
fImpl->CloseCatalog(catalog);
return nullptr;
}
return node_cast(catalog);
}
/// @brief Writes to a catalog
/// @param node
/// @param data
/// @param flags
/// @return
Void NewFilesystemManager::Write(NodePtr node, VoidPtr data, Int32 flags,
SizeT size) {
constexpr const char* cReadAllFork = kNewFSDataFork;
if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
fImpl->WriteCatalog(reinterpret_cast<NewCatalog*>(node), data, size,
cReadAllFork);
}
/**
* NOTE: Write and Read are implemented using a custom NodePtr, retrieved
* using OpenFork.
*/
/// @brief Reads from filesystem.
/// @param node
/// @param flags
/// @param sz
/// @return
VoidPtr NewFilesystemManager::Read(NodePtr node, Int32 flags, SizeT sz) {
constexpr const char* cReadAllFork = kNewFSDataFork;
if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
return fImpl->ReadCatalog(reinterpret_cast<NewCatalog*>(node), sz,
cReadAllFork);
return nullptr;
}
/// @brief Seek from Catalog.
/// @param node
/// @param off
/// @return
bool NewFilesystemManager::Seek(NodePtr node, SizeT off) {
if (!node || off == 0) return false;
return fImpl->Seek(reinterpret_cast<NewCatalog*>(node), off);
}
/// @brief Tell where the catalog is/
/// @param node
/// @return
SizeT NewFilesystemManager::Tell(NodePtr node) {
if (!node) return kNPos;
return fImpl->Tell(reinterpret_cast<NewCatalog*>(node));
}
/// @brief Rewind the catalog.
/// @param node
/// @return
bool NewFilesystemManager::Rewind(NodePtr node) {
if (!node) return false;
return this->Seek(node, 0);
}
/// @brief The filesystem implementation.
/// @return
NewFSParser* NewFilesystemManager::GetImpl() noexcept { return fImpl; }
#endif // __FSKIT_NEWFS__
} // namespace NewOS
|
