Trait LayerExt 

pub trait LayerExt: Fs + Sized {
    // Provided method
    fn layer<L: Layer<Self>>(self, layer: L) -> L::Backend { ... }
}

Extension trait for fluent layer composition.

Provides the .layer() method on any Fs backend for ergonomic chaining.

Example

use anyfs_backend::{Fs, LayerExt, Layer};

// With LayerExt, you can chain layers fluently:
fn compose_backend<B: Fs, L: Layer<B>>(backend: B, layer: L) -> L::Backend {
    backend.layer(layer)
}

Provided Methods

fn layer<L: Layer<Self>>(self, layer: L) -> L::Backend

Apply a layer to this backend.

Returns the wrapped backend with the layer’s functionality added.

Example

use anyfs_backend::{Fs, LayerExt, Layer};

fn add_middleware<B, L>(backend: B, layer: L) -> L::Backend
where
    B: Fs,
    L: Layer<B>,
{
    backend.layer(layer)
}

Examples found in repository

examples/layer_middleware.rs (line 667)

fn main() {
    println!("=== Layer Middleware Example ===\n");

    // Create base filesystem
    let base = MemoryFs::new();

    // Write some initial data
    base.write(Path::new("/config.txt"), b"initial config")
        .unwrap();
    base.create_dir(Path::new("/data")).unwrap();
    base.write(Path::new("/data/file1.txt"), b"file 1 content")
        .unwrap();

    // ===========================================
    // Example 1: Logging layer
    // ===========================================
    println!("--- Example 1: Logging Layer ---\n");

    // Using LayerExt for fluent API
    let logged_fs = base.layer(LoggingLayer);

    println!("Reading a file through logging layer:");
    let _ = logged_fs.read(Path::new("/config.txt"));
    println!();

    // Get base back (we'll use a new one for other examples)
    let base = MemoryFs::new();
    base.write(Path::new("/config.txt"), b"initial config")
        .unwrap();
    base.create_dir(Path::new("/data")).unwrap();
    base.write(Path::new("/data/file1.txt"), b"file 1 content")
        .unwrap();
    base.write(Path::new("/data/file2.txt"), b"file 2 content")
        .unwrap();

    // ===========================================
    // Example 2: Metrics layer
    // ===========================================
    println!("--- Example 2: Metrics Layer ---\n");

    let metrics_layer = MetricsLayer;
    let metrics_fs = metrics_layer.layer(MemoryFs::new());

    // Setup
    metrics_fs.write(Path::new("/a.txt"), b"a").unwrap();
    metrics_fs.write(Path::new("/b.txt"), b"b").unwrap();
    metrics_fs.write(Path::new("/c.txt"), b"c").unwrap();
    let _ = metrics_fs.read(Path::new("/a.txt"));
    let _ = metrics_fs.read(Path::new("/b.txt"));
    metrics_fs.remove_file(Path::new("/c.txt")).unwrap();

    let (reads, writes, deletes) = metrics_fs.stats();
    println!("Metrics: reads={reads}, writes={writes}, deletes={deletes}\n");

    // ===========================================
    // Example 3: Read-only layer
    // ===========================================
    println!("--- Example 3: Read-Only Layer ---\n");

    let readonly_fs = base.layer(ReadOnlyLayer);

    // Reading works
    println!("Reading through read-only layer:");
    match readonly_fs.read(Path::new("/config.txt")) {
        Ok(data) => println!("  Success: {} bytes", data.len()),
        Err(e) => println!("  Error: {e}"),
    }

    // Writing fails
    println!("Writing through read-only layer:");
    match readonly_fs.write(Path::new("/new.txt"), b"test") {
        Ok(()) => println!("  Success (unexpected!)"),
        Err(e) => println!("  Error: {e}"),
    }
    println!();

    // ===========================================
    // Example 4: Composing multiple layers
    // ===========================================
    println!("--- Example 4: Composing Layers ---\n");

    // Create a stack: MemoryFs -> Metrics -> Logging
    // Operations flow: Logging -> Metrics -> MemoryFs
    let base = MemoryFs::new();
    let with_metrics = MetricsLayer.layer(base);
    let with_logging = LoggingLayer.layer(with_metrics);

    println!("Writing through Logging -> Metrics -> Memory:");
    with_logging
        .write(Path::new("/test.txt"), b"hello")
        .unwrap();
    println!();

    println!("Reading through Logging -> Metrics -> Memory:");
    let _ = with_logging.read(Path::new("/test.txt"));
    println!();

    // Access inner metrics
    let (reads, writes, _) = with_logging.inner.stats();
    println!("Inner metrics: reads={reads}, writes={writes}\n");

    // ===========================================
    // Example 5: Using with trait objects
    // ===========================================
    println!("--- Example 5: Layers with Trait Objects ---\n");

    fn use_any_fs(fs: &dyn Fs) {
        let _ = fs.exists(Path::new("/"));
        println!("  Used filesystem through trait object");
    }

    let base = MemoryFs::new();
    let layered = base.layer(LoggingLayer);

    println!("Passing layered FS as &dyn Fs:");
    use_any_fs(&layered);

    println!("\n=== Layer examples complete! ===");
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<B: Fs> LayerExt for B