Struct Resource

pub struct Resource<T, S> { /* private fields */ }

A resource that enforces acquisition and release through the type system

Type Parameters

• T - The underlying resource type
• S - The current state of the resource (phantom type)

Example

use eventcore::resource::{Resource, states, ResourceManager};
use std::sync::Arc;

// Example with database pool resource (requires postgres feature)
// This would typically be used with eventcore-postgres crate:
// ```rust,ignore
// use eventcore::resource::database::{DatabaseResourceManager, DatabasePool};
// use sqlx::PgPool;
//
// let pool = Arc::new(PgPool::connect("postgres://localhost/mydb").await?);
// let manager = DatabaseResourceManager::new(pool);
// let db_resource = manager.acquire_pool().await?;
// let result = db_resource.execute_query("SELECT 1").await?;
// let _released = db_resource.release()?;
// ```

// Example with a custom resource type
struct MyResource {
    data: String,
}

// Implement ResourceManager for your type
struct MyResourceManager;

#[async_trait::async_trait]
impl ResourceManager<MyResource> for MyResourceManager {
    async fn acquire() -> Result<Resource<MyResource, states::Acquired>, eventcore::resource::ResourceError> {
        // In practice, you'd acquire from a pool or create the resource
        let resource = Self::create_initializing(MyResource { data: "example".to_string() });
        Ok(resource.mark_acquired())
    }
}

// Use the resource manager to acquire a resource
let resource = MyResourceManager::acquire().await?;

// Access the inner data (only possible in Acquired state)
let data = resource.get();
println!("Resource data: {}", data.data);

// Transition to released state
let _released: Resource<MyResource, states::Released> = resource.release()?;
// released resource cannot be used anymore (compile-time guarantee)

Implementations

impl<T> Resource<Arc<Mutex<T>>, Acquired>

Extension methods for mutex resources

pub fn lock(&self) -> ResourceResult<MutexGuardResource<'_, T>>

Acquire the mutex lock

Returns a guard resource that enforces lock is held

pub fn try_lock(&self) -> ResourceResult<Option<MutexGuardResource<'_, T>>>

Try to acquire the mutex lock without blocking

Returns None if the lock is currently held

impl<T, S> Resource<T, S>

pub const fn get(&self) -> &T

where S: IsAcquired,

Get a reference to the underlying resource

Only available when resource is acquired

pub fn get_mut(&mut self) -> &mut T

where S: IsAcquired,

Get a mutable reference to the underlying resource

Only available when resource is acquired

pub fn into_inner(self) -> T

where S: IsAcquired,

Consume the resource and return the inner value

Only available when resource is acquired

impl<T> Resource<T, Initializing>

State transitions for resources

pub fn mark_acquired(self) -> Resource<T, Acquired>

Transition from initializing to acquired state

This represents successful resource acquisition

pub fn mark_failed(self) -> Resource<T, Failed>

Transition from initializing to failed state

This represents failed resource acquisition

impl<T> Resource<T, Acquired>

pub fn release(self) -> ResourceResult<Resource<T, Released>>

Release the resource, transitioning to released state

After release, the resource cannot be used anymore

pub fn mark_failed(self) -> Resource<T, Failed>

Mark resource as failed due to an error

Failed resources can be recovered or released

impl<T> Resource<T, Failed>

pub fn recover(self) -> ResourceResult<Resource<T, Acquired>>

Attempt to recover a failed resource

If successful, transitions back to acquired state

pub fn release(self) -> ResourceResult<Resource<T, Released>>

Release a failed resource

This allows cleanup even when the resource is in a failed state

impl<T> Resource<T, Released>

pub const fn is_released(&self) -> bool

Check if resource has been released

This is always true for resources in Released state

impl<T, S> Resource<T, S>

pub fn managed(self, resource_type: &str) -> ManagedResource<T, S>

Create a managed resource for any state

Trait Implementations

impl<T: Debug, S: Debug> Debug for Resource<T, S>

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

Formats the value using the given formatter.

impl<T> ResourceExt<T, Acquired> for Resource<T, Acquired>

fn managed(self, resource_type: &str) -> ManagedResource<T, Acquired>

Wrap in a managed resource for automatic leak detection

fn scoped(self) -> ResourceScope<T>

Wrap in a scoped resource for automatic cleanup

fn with_timeout(self, timeout: Duration) -> TimedResourceGuard<T>

where T: Send + 'static,

Wrap in a timed guard for timeout-based cleanup