Enum ResourceState 

pub enum ResourceState {
    Pooled,
    Owned,
    Borrowed,
    Leased,
    Transit,
    Freed,
}

Resource ownership state machine.

Per Doc 03, Section 3.1-3.2: tracks the lifecycle of host-managed resources (primarily buffers). Extended here with Transit and Freed states.

State transition diagram:

  Pooled -> Owned -> Borrowed -> Owned (borrow released)
                  -> Leased   -> Owned (lease expired)
                  -> Transit  -> Owned (new owner)
                  -> Pooled   (released)
  Any -> Freed (forced cleanup or shutdown)

Examples

use torvyn_types::ResourceState;

let state = ResourceState::Pooled;
assert!(state.can_transition_to(&ResourceState::Owned));
assert!(!state.can_transition_to(&ResourceState::Borrowed));

Variants

Pooled

The resource is in a buffer pool, not in active use.

Owned

The resource is exclusively owned by one entity.

Borrowed

The resource is owned but has outstanding read-only borrows.

Leased

The resource is held under a time- or scope-bounded lease.

Transit

The resource is in transit between owners (host holds temporarily).

Freed

The resource has been freed and its slot may be reused.

Implementations

impl ResourceState

pub fn can_transition_to(&self, target: &ResourceState) -> bool

Returns true if transitioning from self to target is legal.

Legal transitions (per Doc 03, Section 3.2, extended):

• Pooled -> Owned (allocate)
• Owned -> Borrowed (borrow started)
• Owned -> Leased (lease granted)
• Owned -> Transit (transfer initiated)
• Owned -> Pooled (released to pool)
• Owned -> Freed (deallocated)
• Borrowed -> Owned (all borrows released)
• Borrowed -> Borrowed (additional borrow — same state)
• Leased -> Owned (lease expired/released)
• Transit -> Owned (transfer completed to new owner)
• Any -> Freed (forced cleanup: crash, shutdown)

HOT PATH — called per resource state change.

pub fn transition_to( self, target: ResourceState, ) -> Result<ResourceState, InvalidTransition>

Attempt to transition from self to target.

Returns Ok(target) if the transition is legal, or Err(InvalidTransition) if it is not.

HOT PATH — called per resource state change.

pub const fn is_terminal(&self) -> bool

Returns true if this state is terminal.

pub const fn is_available(&self) -> bool

Returns true if the resource is available for allocation from a pool.

pub const fn is_active(&self) -> bool

Returns true if the resource has an active owner.

Trait Implementations

impl Clone for ResourceState

fn clone(&self) -> ResourceState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResourceState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResourceState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ResourceState

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

Formats the value using the given formatter.

impl Hash for ResourceState

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 ResourceState

fn eq(&self, other: &ResourceState) -> 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 Serialize for ResourceState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ResourceState

impl Eq for ResourceState

impl StructuralPartialEq for ResourceState