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

Binary file time

Browse Source
This commit is contained in:
rhpidfyre
2025-03-22 21:29:44 -04:00
parent 0483e2a0df
commit 56790cbe1d
3 changed files with 156 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/rt/rfwfs/enum.ts
View File

@ -1,17 +1,13 @@
type ConstEnum = number
const enum EntryType {
Root,
File,
Directory,
Binary,
File,
}
const enum Permissions {
r,
w,
rw,
none,
}
const enum PermissionsBinary {
r,
w,
x,
@ -21,16 +17,25 @@ const enum PermissionsBinary {
wx,
none,
}
const enum PushStatus {
Ok,
Duplicate,
Denied,
}
const enum ReadStatus {
Ok,
NotFound,
Denied,
}
const enum ExecuteStatus {
Ok,
Panic,
Denied,
}
const enum Option {
Ok,
None,
@ -38,7 +43,7 @@ const enum Option {
export {
type ConstEnum,
PermissionsBinary,
ExecuteStatus,
Permissions,
PushStatus,
ReadStatus,

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

@ -1,47 +1,64 @@
import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsBinary } from "./enum"
import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
import { EntryType, PushStatus, ReadStatus, Permissions, ExecuteStatus } from "./enum"
import { wrap_entry, wrap_none, type WrapResultEntry, type WrapResultNone, type WrapBinary, wrap_binary } from "./wrap"
import directory_search from "./index"
type FileInner = string | number
type BinaryError = string
interface Entry {
type BinaryEntry = () => EntryStripped
type BinaryLambda = (binary_entry: BinaryEntry) => void
type Directory<T extends Entry> = EntryCollection<T>
type DirectoryAny = EntryCollection<Entry>
type DirectoryAnyDepth = EntryCollection<DirectoryAny>
interface Root<T extends Entry> {
readonly type: EntryType,
inner: T[],
}
interface EntryStripped {
readonly type: EntryType,
permissions: Permissions,
timestamp: EntryValue<number>,
name: EntryValue<string>,
readonly type: EntryType,
}
interface Entry extends EntryStripped {
parent: DirectoryAny,
}
interface EntryFile extends Entry {
inner: EntryValue<FileInner>,
hash: string,
}
interface EntryCollection<T extends Entry> extends Entry {
inner: RfwfsDirectory<T>,
}
interface Rfwfs {
directory: <T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]) => EntryCollection<T>,
file: (default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: FileInner) => EntryFile,
is_binary: <T extends Entry>(entry: T) => boolean,
is_file: <T extends Entry>(entry: T) => boolean,
is_dir: <T extends Entry>(entry: T) => boolean,
interface EntryBinary extends Entry {
inner: RfwfsBinary
}
function execute_access<P extends ConstEnum>(permissions: P): boolean {
return permissions === PermissionsBinary.rwx
|| permissions === PermissionsBinary.rx
|| permissions === PermissionsBinary.wx
|| permissions === PermissionsBinary.x
function strip_entry<T extends Entry>(entry: T): EntryStripped {
return {
type: entry.type,
permissions: entry.permissions,
timestamp: entry.timestamp,
name: entry.name,
}
function read_write_access<P extends ConstEnum>(permissions: P): boolean {
}
function execute_access(permissions: Permissions): boolean {
return permissions === Permissions.rwx
|| permissions === Permissions.rx
|| permissions === Permissions.wx
|| permissions === Permissions.x
}
function read_write_access(permissions: Permissions): boolean {
return permissions === Permissions.rw
}
function read_access<P extends ConstEnum>(permissions: P): boolean {
function read_access(permissions: Permissions): boolean {
return read_write_access(permissions) || permissions === Permissions.r
}
function write_access<P extends ConstEnum>(permissions: P): boolean {
function write_access(permissions: Permissions): boolean {
return read_write_access(permissions) || permissions === Permissions.w
}
@ -69,7 +86,7 @@ class EntryValue<T> {
class RfwfsDirectory<T extends Entry> {
public directory: T[];
protected entry: Entry
protected entry: Entry;
constructor(entry: Entry, directory: T[]) {
this.directory = directory
@ -128,21 +145,61 @@ class RfwfsDirectory<T extends Entry> {
}
}
const rfwfs = {} as Rfwfs
class RfwfsBinary {
public lambda: BinaryLambda;
protected entry: Entry;
rfwfs.is_dir = function(entry) {
constructor(entry: Entry, lambda: BinaryLambda) {
this.lambda = lambda
this.entry = entry
}
public execute(): WrapBinary {
if (execute_access(this.entry.permissions)) {
try {
this.lambda(() => strip_entry(this.entry))
} catch(binary_e) {
return wrap_binary(ExecuteStatus.Panic, (binary_e as object).toString())
}
return wrap_binary(ExecuteStatus.Ok)
}
return wrap_binary(ExecuteStatus.Denied)
}
}
class rfwfs_static {
public static is_dir<T extends Entry>(entry: T): boolean {
return entry.type === EntryType.Directory
}
rfwfs.is_file = function(entry) {
public static is_file<T extends Entry>(entry: T): boolean {
return entry.type === EntryType.File
}
rfwfs.is_binary = function(entry) {
public static is_binary<T extends Entry>(entry: T): boolean {
return entry.type === EntryType.Binary
}
public static is_root<T extends Entry>(entry: Root<T>): boolean {
return entry.type === EntryType.Root
}
}
rfwfs.file = function(default_name, default_permissions, default_timestamp, default_inner) {
class rfwfs<T extends Entry> extends rfwfs_static {
protected root: Root<T>;
constructor(inner: T[]) {
super()
this.root = { type: EntryType.Root, inner: inner }
}
public file(
default_name: string,
default_permissions: Permissions,
default_parent: DirectoryAny,
default_timestamp?: number,
default_inner?: FileInner
): EntryFile {
const file = { type: EntryType.File } as EntryFile
file.hash = "0"
file.parent = default_parent
file.permissions = default_permissions
file.timestamp = new EntryValue(file, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
file.inner = new EntryValue(file, default_inner ? default_inner : "")
@ -150,8 +207,15 @@ rfwfs.file = function(default_name, default_permissions, default_timestamp, defa
return file
}
rfwfs.directory = function<T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]): EntryCollection<T> {
public directory<T extends Entry>(
default_name: string,
default_permissions: Permissions,
default_parent: DirectoryAny,
default_timestamp?: number,
default_inner?: T[]
): EntryCollection<T> {
const directory = { type: EntryType.Directory } as EntryCollection<T>
directory.parent = default_parent
directory.permissions = default_permissions
directory.timestamp = new EntryValue(directory, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
directory.inner = new RfwfsDirectory(directory, default_inner ? default_inner : [])
@ -159,10 +223,31 @@ rfwfs.directory = function<T extends Entry>(default_name: string, default_permis
return directory
}
public binary(
default_name: string,
default_permissions: Permissions,
default_parent: DirectoryAny,
default_timestamp?: number,
default_inner?: BinaryLambda
): EntryBinary {
const binary = { type: EntryType.Binary } as EntryBinary
binary.parent = default_parent
binary.permissions = default_permissions
binary.timestamp = new EntryValue(binary, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
binary.inner = new RfwfsBinary(binary, default_inner ? default_inner : () => {})
binary.name = new EntryValue(binary, default_name)
return binary
}
}
export default rfwfs
export {
type EntryCollection,
type DirectoryAnyDepth,
type RfwfsDirectory,
type DirectoryAny,
type BinaryError,
type Directory,
type FileInner,
type EntryFile,
type Entry,

17
src/rt/rfwfs/wrap.ts
View File

@ -1,9 +1,10 @@
import { Option, type ConstEnum } from "./enum"
import { type Entry } from "./main"
import { ExecuteStatus, Option, type ConstEnum } from "./enum"
import { type BinaryError, type Entry } from "./main"
type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
type WrapBSearch<T extends Entry> = WrapResult<T, number>
type WrapResultNone<T> = WrapResult<Option.None, T>
type WrapBinary = WrapResult<ExecuteStatus, BinaryError | undefined>
interface WrapResult<T, U> {
/** The resulting value if `U` is a success status */
@ -28,13 +29,19 @@ function wrap_none<T extends ConstEnum>(status: T): WrapResultNone<T> {
return wrap(Option.None, status)
}
function wrap_binary(status: ExecuteStatus, result?: BinaryError): WrapBinary {
return wrap(status, result)
}
export default wrap
export {
wrap_bsearch,
wrap_entry,
wrap_none,
type WrapResultEntry,
type WrapResultNone,
type WrapBSearch,
type WrapResult,
type WrapBinary,
wrap_bsearch,
wrap_binary,
wrap_entry,
wrap_none,
}