Struct Opfs 

pub struct Opfs {
    pub(crate) root: FileSystemDirectoryHandle,
    pub(crate) dir: FileSystemDirectoryHandle,
    pub(crate) name: Name,
    pub(crate) held: RefCell<Option<Held>>,
}

One container’s directory in origin-private storage.

Fields

root: FileSystemDirectoryHandle

The origin’s root, which a rename and a discard reach the container through rather than reaching into it.

dir: FileSystemDirectoryHandle

name: Name

held: RefCell<Option<Held>>

Implementations

impl Opfs

pub(crate) async fn within( &self, at: &Entry, missing: Missing, ) -> Result<(FileSystemDirectoryHandle, String)>

The directory at is held in — made along the way where a write is what asked — and the name it is held under.

pub(crate) async fn entry( &self, at: &Entry, missing: Missing, ) -> Result<FileSystemFileHandle>

pub(crate) async fn walk( &self, path: &[&str], missing: Missing, ) -> Result<FileSystemDirectoryHandle>

pub(crate) fn lock_name(name: &Name) -> String

Trait Implementations

impl Debug for Opfs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Storage for Opfs

async fn exists<'a>(&'a self, at: &'a Entry) -> Result<bool>

A name a directory stands under answers false rather than the browser’s refusal, which is what a map answers too: this is asked about entries, and the container’s own directories are laid out rather than looked for.

async fn rename<'a>(&'a mut self, to: &'a Name) -> Result<()>

The bytes travel, since only Chromium has move(), and the lock goes with them: it is named after the container, so a rename must take the new name’s lock as well as the new name.

Both are taken before anything moves. A view claiming a name whose directory it has not laid down yet holds that lock and nothing else, so a rename that copied first and asked afterwards would find the lock gone and carry on writing a container it no longer holds.

async fn claim(&self, _now: WallTime) -> Result<Claim>

now names nobody here: the origin’s lock manager records no holder, only that the lock is held, which is why a refusal is [Holding::Elsewhere].

fn name(&self) -> Name

What this container is called.

fn names(&self, at: &Entry) -> String

What a report calls at — a platform path where there is one. Not a promise that anything is there.

fn residency(&self) -> Residency

async fn read<'a>(&'a self, at: &'a Entry) -> Result<Option<Vec<u8>>>

The bytes at at, or None where nothing is — which is not the same as a read that did not work.

async fn write<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Result<()>

Whole file or nothing: a reader caught mid-write sees the previous contents, never half of each.

async fn append<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Result<()>

Add bytes to the end of at, durably before returning.

async fn truncate<'a>(&'a self, at: &'a Entry, len: u64) -> Result<()>

async fn list<'a>(&'a self, dir: &'a Entry) -> Result<Vec<String>>

What dir holds, by name, in no particular order.

async fn remove<'a>(&'a self, at: &'a Entry) -> Result<()>

async fn create_dir<'a>(&'a self, dir: &'a Entry) -> Result<()>

Make dir a place entries can be written.

async fn discard(&self) -> Result<()>

Remove the container itself. Only ever asked of one that has been emptied.

fn release(&self)

Give the lock back.

fn disk_path(&self) -> Option<&Path>

Where these bytes sit on a filesystem, for a shell that can name one. None for a storage that has no such thing.