Struct Handle 

pub struct Handle(pub u64);

Opaque file handle for POSIX-style I/O operations.

Represents an open file descriptor. Used with FsHandles for handle-based read/write operations, and with FsLock for file locking.

Lifecycle

1. Open: Call FsHandles::open to get a handle
2. Use: Call read_at, write_at, lock, etc.
3. Close: Call FsHandles::close to release

Example

use anyfs_backend::{FsHandles, OpenFlags, Handle};
use std::path::Path;

// Generic function that works with any FsHandles implementation
fn write_with_handle<B: FsHandles>(fs: &B) -> Result<(), anyfs_backend::FsError> {
    // Open file for writing
    let handle: Handle = fs.open(Path::new("/data.bin"), OpenFlags::WRITE)?;
     
    // Write at specific offset
    fs.write_at(handle, b"Hello", 0)?;
    fs.write_at(handle, b"World", 5)?;
     
    // Always close the handle
    fs.close(handle)?;
    Ok(())
}

Internal Value

The u64 value is backend-defined. It could be an inode number, array index, or any other unique identifier. Treat it as opaque.

Tuple Fields

0: u64

Trait Implementations

impl Clone for Handle

fn clone(&self) -> Handle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Handle

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

Formats the value using the given formatter.

impl Hash for Handle

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Handle

fn eq(&self, other: &Handle) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Handle

impl Eq for Handle

impl StructuralPartialEq for Handle