From c66a0eb4a99ec8d945c1f9b7da2238505d301ec8 Mon Sep 17 00:00:00 2001 From: rhpidfyre Date: Fri, 14 Mar 2025 17:39:07 -0400 Subject: [PATCH] prototyping with classes for Inner and Rfwfs directory --- src/rt/rfwfs/main.ts | 127 +++++++++++++++++++++---------------------- 1 file changed, 62 insertions(+), 65 deletions(-) diff --git a/src/rt/rfwfs/main.ts b/src/rt/rfwfs/main.ts index 88f49d5..ce9c66d 100644 --- a/src/rt/rfwfs/main.ts +++ b/src/rt/rfwfs/main.ts @@ -7,7 +7,6 @@ import hash_table from "./hash" type FileInner = string | number type EntryFileInner = EntryValue -//please do not change the inner values directly on entries or else there will be catastrophic consequences interface EntryValue { __inner: T, write: (value: T) => boolean, @@ -58,85 +57,83 @@ function write_access

(permissions: P): boolean { return read_write_access(permissions) || permissions === Permissions.w } -function directory_sort(self: EntryCollectionManipulate) { - self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read())) -} +class Inner { + private inner: T; -function directory_push(self: EntryCollection, entry: E): WrapResultNone { - if (read_write_access(self.permissions)) { - const no_duplicates = directory_search(self.inner.__inner, entry.name.read()) - if (!no_duplicates) { - self.inner.__inner.push(entry) - self.inner.__inner.sort() - return wrap_none(PushStatus.Ok) + constructor(inner_default: T) { + this.inner = inner_default + } + + public write

(dyn_permissions: P, item: I): boolean { + if (write_access(dyn_permissions)) { + this.inner = item + return true } - return wrap_none(PushStatus.Duplicate) + return false + } + + public read

(dyn_permissions: P): T | undefined { + return read_access(dyn_permissions) ? this.inner : undefined } - return wrap_none(PushStatus.Denied) } -function directory_find(self: EntryCollection, file_name: string): WrapResultEntry { - if (read_write_access(self.permissions)) { - const file_search = directory_search(self.inner.__inner, file_name) - if (file_search) { - return wrap_entry(ReadStatus.Ok, file_search.result) +class RfwfsDirectory { + private inner: T[]; + + constructor(inner: T[]) { + this.inner = inner + } + + public sort() { + this.inner.sort((a,z) => a.name.read().localeCompare(z.name.read())) + } + + public clone

(dyn_permissions: P, file_name: string): WrapResultEntry { + if (read_write_access(dyn_permissions)) { + const clone_find = directory_search(this.inner, file_name) + if (clone_find) { + return wrap_entry(ReadStatus.Ok, { ...clone_find.result }) + } + return wrap_entry(ReadStatus.NotFound) } - return wrap_entry(ReadStatus.NotFound) + return wrap_entry(ReadStatus.Denied) } - return wrap_entry(ReadStatus.Denied) -} -function directory_pop(self: EntryCollection, file_name: string): WrapResultEntry { - if (read_write_access(self.permissions)) { - const pop_find = directory_search(self.inner.__inner, file_name) - if (pop_find) { - self.inner.__inner.splice(pop_find.some, 1) - return wrap_entry(ReadStatus.Ok, pop_find.result) + public find

(dyn_permissions: P, file_name: string): WrapResultEntry { + 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.NotFound) + return wrap_entry(ReadStatus.Denied) } - return wrap_entry(ReadStatus.Denied) -} -function directory_clone(self: EntryCollection, file_name: string): WrapResultEntry { - if (read_write_access(self.permissions)) { - const clone_find = directory_search(self.inner.__inner, file_name) - if (clone_find) { - return wrap_entry(ReadStatus.Ok, { ...clone_find.result }) + public push

(dyn_permissions: P, entry: E): WrapResultNone { + if (read_write_access(dyn_permissions)) { + const no_duplicates = directory_search(this.inner, entry.name.read()) + if (!no_duplicates) { + this.inner.push(entry) + this.inner.sort() + return wrap_none(PushStatus.Ok) + } + return wrap_none(PushStatus.Duplicate) } - return wrap_entry(ReadStatus.NotFound) + return wrap_none(PushStatus.Denied) } - return wrap_entry(ReadStatus.Denied) -} -function inner_read(self: EntryValue, permissions: P): FileInner | undefined { - return read_access(permissions) ? self.__inner : undefined -} - -function inner_write(self: EntryValue, permissions: P, item: I): boolean { - if (write_access(permissions)) { - self.__inner = item - return true + public pop

(dyn_permissions: P, file_name: string): WrapResultEntry { + if (read_write_access(dyn_permissions)) { + const pop_find = directory_search(this.inner, file_name) + if (pop_find) { + 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) } - return false -} - -function inner

>(permissions: P, inner_default: I): R { - const inner_trait = { __inner: inner_default } as R - inner_trait.write = function(item) { return inner_write(this, permissions, item) } - inner_trait.read = function() { return inner_read(this, permissions) } - return inner_trait -} - -function dir_inner(self: EntryCollection, collection: T[]): EntryCollectionManipulate { - const collection_trait = { __inner: collection } as EntryCollectionManipulate - 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