rhpidfyre.io/wunix.rhpidfyre.io
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

prototyping with classes for Inner and Rfwfs directory

Browse Source
This commit is contained in:
rhpidfyre
2025-03-14 17:39:07 -04:00
parent caedb7e8f0
commit c66a0eb4a9
1 changed files with 62 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
src/rt/rfwfs/main.ts
View File

@ -7,7 +7,6 @@ import hash_table from "./hash"
type FileInner = string | number type FileInner = string | number
type EntryFileInner = EntryValue<FileInner, FileInner | undefined> type EntryFileInner = EntryValue<FileInner, FileInner | undefined>
//please do not change the inner values directly on entries or else there will be catastrophic consequences
interface EntryValue<T, U = T> { interface EntryValue<T, U = T> {
__inner: T, __inner: T,
write: (value: T) => boolean, write: (value: T) => boolean,
@ -58,49 +57,40 @@ function write_access<P extends ConstEnum>(permissions: P): boolean {
return read_write_access(permissions) || permissions === Permissions.w return read_write_access(permissions) || permissions === Permissions.w
} }
function directory_sort<E extends Entry>(self: EntryCollectionManipulate<E>) { class Inner<T> {
self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read())) private inner: T;
constructor(inner_default: T) {
this.inner = inner_default
} }
function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): WrapResultNone<PushStatus> { public write<P extends ConstEnum, I extends T>(dyn_permissions: P, item: I): boolean {
if (read_write_access(self.permissions)) { if (write_access(dyn_permissions)) {
const no_duplicates = directory_search(self.inner.__inner, entry.name.read()) this.inner = item
if (!no_duplicates) { return true
self.inner.__inner.push(entry)
self.inner.__inner.sort()
return wrap_none(PushStatus.Ok)
} }
return wrap_none(PushStatus.Duplicate) return false
}
return wrap_none(PushStatus.Denied)
} }
function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> { public read<P extends ConstEnum>(dyn_permissions: P): T | undefined {
if (read_write_access(self.permissions)) { return read_access(dyn_permissions) ? this.inner : undefined
const file_search = directory_search(self.inner.__inner, file_name)
if (file_search) {
return wrap_entry(ReadStatus.Ok, file_search.result)
} }
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
} }
function directory_pop<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> { class RfwfsDirectory<T extends Entry> {
if (read_write_access(self.permissions)) { private inner: T[];
const pop_find = directory_search(self.inner.__inner, file_name)
if (pop_find) { constructor(inner: T[]) {
self.inner.__inner.splice(pop_find.some, 1) this.inner = inner
return wrap_entry(ReadStatus.Ok, pop_find.result)
}
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
} }
function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> { public sort() {
if (read_write_access(self.permissions)) { this.inner.sort((a,z) => a.name.read().localeCompare(z.name.read()))
const clone_find = directory_search(self.inner.__inner, file_name) }
public clone<P extends ConstEnum>(dyn_permissions: P, file_name: string): WrapResultEntry<T, ReadStatus> {
if (read_write_access(dyn_permissions)) {
const clone_find = directory_search(this.inner, file_name)
if (clone_find) { if (clone_find) {
return wrap_entry(ReadStatus.Ok, { ...clone_find.result }) return wrap_entry(ReadStatus.Ok, { ...clone_find.result })
} }
@ -109,34 +99,41 @@ function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: s
return wrap_entry(ReadStatus.Denied) return wrap_entry(ReadStatus.Denied)
} }
function inner_read<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P): FileInner | undefined { public find<P extends ConstEnum>(dyn_permissions: P, file_name: string): WrapResultEntry<T, ReadStatus> {
return read_access(permissions) ? self.__inner : undefined if (read_write_access(dyn_permissions)) {
const file_search = directory_search(this.inner, file_name)
if (file_search) {
return wrap_entry(ReadStatus.Ok, file_search.result)
}
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
} }
function inner_write<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P, item: I): boolean { public push<P extends ConstEnum, E extends T>(dyn_permissions: P, entry: E): WrapResultNone<PushStatus> {
if (write_access(permissions)) { if (read_write_access(dyn_permissions)) {
self.__inner = item const no_duplicates = directory_search(this.inner, entry.name.read())
return true if (!no_duplicates) {
this.inner.push(entry)
this.inner.sort()
return wrap_none(PushStatus.Ok)
} }
return false return wrap_none(PushStatus.Duplicate)
}
return wrap_none(PushStatus.Denied)
} }
function inner<P extends ConstEnum, I, R extends EntryValue<I>>(permissions: P, inner_default: I): R { public pop<P extends ConstEnum>(dyn_permissions: P, file_name: string): WrapResultEntry<T, ReadStatus> {
const inner_trait = { __inner: inner_default } as R if (read_write_access(dyn_permissions)) {
inner_trait.write = function(item) { return inner_write(this, permissions, item) } const pop_find = directory_search(this.inner, file_name)
inner_trait.read = function() { return inner_read(this, permissions) } if (pop_find) {
return inner_trait this.inner.splice(pop_find.some, 1)
return wrap_entry(ReadStatus.Ok, pop_find.result)
}
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
} }
function dir_inner<T extends Entry>(self: EntryCollection<T>, collection: T[]): EntryCollectionManipulate<T> {
const collection_trait = { __inner: collection } as EntryCollectionManipulate<T>
collection_trait.clone = function(file_name) { return directory_clone(self, file_name) }
collection_trait.find = function(file_name) { return directory_find(self, file_name) }
collection_trait.push = function(entry) { return directory_push(self, entry) }
collection_trait.sort = function() { return directory_sort(this) }
collection_trait.pop = function(file_name) { return directory_pop(self, file_name) }
collection_trait.sort() //the default collection is automatically sorted on directory creation.
return collection_trait
} }
const rfwfs = {} as Rfwfs const rfwfs = {} as Rfwfs