aimx/values/

instance.rs

use crate::{
    aim::{Context, WorkflowLike, Workspace, Writer, WriterLike},
    expressions::Reference, reference::parse_reference,
};
use std::{
    fmt,
    sync::{Arc, RwLock}
};
use anyhow::Result;
use nom::{
    IResult, Parser,
    character::complete::{char, multispace0},
    sequence::{delimited, preceded},
};

#[derive(Debug, Clone)]
enum InstanceState {
    /// Context is not loaded; holds the [`Reference`] used to load it.
    Unloaded { source: Arc<Reference>, target: Arc<Reference> },
    /// Context is loaded; holds the mutable context.
    Loaded { context: Arc<RwLock<Context>> },
}

#[derive(Debug, Clone)]
pub struct Instance {
    /// Internal state protected by read-write lock
    inner: Arc<RwLock<InstanceState>>,
}

impl Instance {
    pub fn new( source: Arc<Reference>, target: Arc<Reference>) -> Self {
        Instance {
            inner: Arc::new(RwLock::new(InstanceState::Unloaded {
                source,
                target,
            })),
        }
    }
/*
    pub fn handle() -> Arc<str> {
        // Generate a random identifier handle with leading underscore and fixed number
        // of digits that has a high probability of being unique
        const RAND_LENGTH: usize = 5; // 2 x 5 random alphanumeric characters = 62^10 possible combinations
        const ALPHANUMERIC_CHARS: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        
        let mut rng = rand::rng();
        let mut handle = String::with_capacity(2 + (2 * RAND_LENGTH));

        handle.push('_');
        for _ in 0..RAND_LENGTH {
            let idx = rng.random_range(0..ALPHANUMERIC_CHARS.len());
            handle.push(ALPHANUMERIC_CHARS[idx] as char);
        }
        for _ in 0..RAND_LENGTH {
            let idx = rng.random_range(0..ALPHANUMERIC_CHARS.len());
            handle.push(ALPHANUMERIC_CHARS[idx] as char);
        }
        handle.push('_');
        
        Arc::from(handle)
    }
*/

    pub fn locate(handle: &str) -> Result<Arc<RwLock<Context>>> {
        let locator = Reference::context();
        let instance = Workspace::locate_instance(&locator, handle)?;
        instance.get_context_lock()
    }

    pub fn get_context_lock(&self) -> Result<Arc<RwLock<Context>>> {
        // Fast path: try read lock
        let read_guard = self.inner.read()
            .expect("Lock poisoned in get_context_lock() instance read.");
        
        match &*read_guard {
            InstanceState::Loaded { context } => {
                Ok(context.clone())
            }
            InstanceState::Unloaded { source: _, target: _} => {
                // Release read lock before acquiring write lock
                drop(read_guard);
                
                // Slow path: acquire write lock
                let mut write_guard = self.inner.write()
                    .expect("Lock poisoned in get_context_lock() instance write.");
                
                // Double-check pattern
                match &*write_guard {
                    InstanceState::Loaded { context } => {
                        Ok(context.clone())
                    }
                    InstanceState::Unloaded { source, target } => {
                        // Load context
                        let ctx = Context::open(source.clone(), target.clone())?;
                        let context = Arc::new(RwLock::new(ctx));
                        
                        // Update state
                        *write_guard = InstanceState::Loaded {
                            context: context.clone(),
                        };

                        Ok(context)
                    }
                }
            }
        }
    }

    pub fn compact(&self) {
        // Check if loaded
        let read_guard = self.inner.read()
            .expect("Lock poisoned in compact() instance read.");

        if let InstanceState::Loaded { context: _ } = &*read_guard {
            drop(read_guard);                
            let mut write_guard = self.inner.write()
                .expect("Lock poisoned in compact() instance write.");

            // Double-check pattern
            if let InstanceState::Loaded { context } = &*write_guard {
                let rwlock_context = context.clone();
                let mut context_guard = rwlock_context.write()
                    
                        .expect("Lock poisoned in compact() context write.");
                if !context_guard.target().is_touched() {
                    let source = context_guard.source().locator();
                    let target = context_guard.target().locator();
                    // Flush
                    *write_guard = InstanceState::Unloaded { source, target };
                }
            }
        }
    }

    /// Saves the instance's target workflow and any related state.
    pub fn save_all(&self) -> Result<()> {
        // Fast path: try read lock
        let read_guard = self.inner.read()
            .expect("Lock poisoned in save_all() instance read.");
        
        match &*read_guard {
            InstanceState::Loaded { context } => {
                let mut write_guard = context.write()
                    .expect("Lock poisoned in save_all() context write.");
                write_guard.save_all()
            }
            // Lets assume that if its unloaded its already been saved
            _ => Ok(()),
        }
    }

    pub fn print(&self, writer: &mut Writer) {
        let read_guard = self.inner.read()
            .expect("Lock poisoned in print() instance read.");
        match &*read_guard {
            InstanceState::Loaded { context } => {
                let context_guard = context.read()
                    .expect("Lock poisoned in print() context read.");
                context_guard.print(writer);
            }
            InstanceState::Unloaded { source, target} => {
                source.print(writer);
                writer.write_str(", ");
                target.print(writer);
            }
        }
    }
}

pub fn parse_instance(input: &str) -> IResult<&str, Instance> {
    let (input, (source, target)) = delimited(
        multispace0,
        // Inner content: source, target
        (
            parse_reference,
            preceded(
                (multispace0, char(','), multispace0),
                parse_reference,
            ),
        ),
        multispace0,
    ).parse(input)?;

    Ok((input, Instance::new(source, target)))
}

impl PartialEq for Instance {
    /// Equality is based on shared internal `Arc` identity, not workflow content.
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.inner, &other.inner)
    }
}

impl WriterLike for Instance {
    fn write(&self, writer: &mut Writer) {
        self.print(writer);
    }
}

impl fmt::Display for Instance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_stringized())
    }
}