Struct ConsumableShared 

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

Specialized shared wrapper for types that can be consumed (like servers)

This wrapper allows the inner value to be extracted for consumption (such as running a server), after which the wrapper becomes unusable.

Examples

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

struct Server {
    name: String,
}

impl Server {
    fn new(name: String) -> Self {
        Self { name }
    }

    fn run(self) -> String {
        format!("Running server: {}", self.name)
    }

    fn status(&self) -> String {
        format!("Server {} is ready", self.name)
    }
}

let server = Server::new("test".to_string());
let shared = ConsumableShared::new(server);
let shared_clone = shared.clone();

// Check status before consumption
let status = shared.with(|s| s.status()).await?;
assert_eq!(status, "Server test is ready");

// Consume the server
let server = shared.consume().await?;
let result = server.run();
assert_eq!(result, "Running server: test");

// Wrapper is now unusable (using clone)
assert!(shared_clone.with(|s| s.status()).await.is_err());

Implementations

impl<T> ConsumableShared<T>

where T: Send + 'static,

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

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

Execute a closure with read access to the inner value

Returns an error if the value has been consumed.

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

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

Execute a closure with mutable access to the inner value

Returns an error if the value has been consumed.

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

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

Execute an async closure with read access to the inner value

Returns an error if the value has been consumed.

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

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

Execute an async closure with mutable access to the inner value

Returns an error if the value has been consumed.

pub async fn consume(self) -> Result<T, SharedError>

Consume the inner value, making the wrapper unusable

This extracts the value from the wrapper, after which all other operations will return SharedError::Consumed.

pub async fn is_available(&self) -> bool

Check if the value is still available (not consumed)

Trait Implementations

impl<T> Clone for ConsumableShared<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 ConsumableShared<T>

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

Formats the value using the given formatter.

impl<T> Shareable<T> for ConsumableShared<T>

where T: Send + 'static,

fn new(inner: T) -> Self

Create a new shared wrapper around the inner type