Struct Shared 

pub struct Shared<T> { /* private fields */ }

A generic shared wrapper that implements the Shareable pattern

This provides a concrete implementation of the sharing pattern that can be used directly for simple cases where no custom behavior is needed.

Examples

use turbomcp_core::shared::{Shared, Shareable};

#[derive(Debug)]
struct Counter {
    value: u64,
}

impl Counter {
    fn new() -> Self {
        Self { value: 0 }
    }

    fn increment(&mut self) {
        self.value += 1;
    }

    fn get(&self) -> u64 {
        self.value
    }
}

// Create a shared counter
let counter = Counter::new();
let shared = Shared::new(counter);

// Clone for use in multiple tasks
let shared1 = shared.clone();
let shared2 = shared.clone();

// Use in concurrent tasks
let handle1 = tokio::spawn(async move {
    shared1.with_mut(|c| c.increment()).await;
});

let handle2 = tokio::spawn(async move {
    shared2.with(|c| c.get()).await
});

Implementations

impl<T> Shared<T>

where T: Send + 'static,

pub async fn with<F, R>(&self, f: F) -> R

where F: FnOnce(&T) -> R + Send,

Execute a closure with read access to the inner value

pub async fn with_mut<F, R>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R + Send,

Execute a closure with mutable access to the inner value

pub async fn with_async<F, Fut, R>(&self, f: F) -> R

where F: FnOnce(&T) -> Fut + Send, Fut: Future<Output = R> + Send,

Execute an async closure with read access to the inner value

pub async fn with_mut_async<F, Fut, R>(&self, f: F) -> R

where F: FnOnce(&mut T) -> Fut + Send, Fut: Future<Output = R> + Send,

Execute an async closure with mutable access to the inner value

pub fn try_with<F, R>(&self, f: F) -> Option<R>

where F: FnOnce(&T) -> R + Send,

Try to execute a closure with read access, returning None if the lock is busy

pub fn try_with_mut<F, R>(&self, f: F) -> Option<R>

where F: FnOnce(&mut T) -> R + Send,

Try to execute a closure with mutable access, returning None if the lock is busy

Trait Implementations

impl<T> Clone for Shared<T>

where T: Send + 'static,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Shared<T>

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

Formats the value using the given formatter.

impl<T> Shareable<T> for Shared<T>

where T: Send + 'static,

fn new(inner: T) -> Self

Create a new shared wrapper around the inner type