capability-example 0.1.0

// ---------------- [ File: capability-example/src/clipboard_snippet.rs ]
crate::ix!();

/// Helper function for “precise parse” of StrippedStringSkeleton
pub fn precise_parse_clipboard_stripped_skeleton() -> Result<StrippedStringSkeleton, std::io::Error> {
    let mut ctx = ClipboardContext::new().map_err(|e| {
        std::io::Error::new(std::io::ErrorKind::Other, format!("Clipboard context error: {e}"))
    })?;
    let contents = ctx.get_contents().map_err(|e| {
        std::io::Error::new(std::io::ErrorKind::Other, format!("Clipboard get_contents error: {e}"))
    })?;
    let json_val: serde_json::Value = serde_json::from_str(&contents).map_err(|e| {
        std::io::Error::new(std::io::ErrorKind::InvalidData, format!("Clipboard JSON parse error: {e}"))
    })?;
    let parsed = try_deserialize_with_path::<StrippedStringSkeleton>(&json_val).map_err(|e| {
        std::io::Error::new(std::io::ErrorKind::InvalidData, format!("StrippedStringSkeleton parse error: {e}"))
    })?;
    Ok(parsed)
}

/// Simple enum to hold whichever snippet we parsed successfully.
#[derive(Debug)]
pub enum ClipboardSnippet {
    JustifiedGrowerTreeConfiguration(JustifiedGrowerTreeConfiguration),
    JustifiedStringSkeleton(JustifiedStringSkeleton),
    StrippedStringSkeleton(StrippedStringSkeleton),
    CoreStringSkeleton(CoreStringSkeleton),
    AnnotatedLeafHolderExpansions(AnnotatedLeafHolderExpansions),
}

impl ClipboardSnippet {

    /// Return the target_name from whichever snippet we hold
    pub fn target_name(&self) -> Option<&String> {
        match self {
            ClipboardSnippet::JustifiedGrowerTreeConfiguration(cfg) => Some(cfg.target_name()),
            ClipboardSnippet::JustifiedStringSkeleton(sk)           => Some(sk.target_name()),
            ClipboardSnippet::StrippedStringSkeleton(sk)            => Some(sk.target_name()),
            ClipboardSnippet::CoreStringSkeleton(sk)                => Some(sk.target_name()),
            ClipboardSnippet::AnnotatedLeafHolderExpansions(ann)    => Some(ann.target_name()),
        }
    }

    /// Decide if this snippet’s type matches the given missing partial step 
    pub fn matches_missing_field(
        &self,
        missing: Option<GrowerModelGenerationInvalidPartial>
    ) -> bool {
        use GrowerModelGenerationInvalidPartial::*;
        match (missing, self) {
            (Some(MissingJustifiedGrowerTreeConfiguration), ClipboardSnippet::JustifiedGrowerTreeConfiguration(_)) => true,
            (Some(MissingJustifiedStringSkeleton),          ClipboardSnippet::JustifiedStringSkeleton(_))          => true,
            (Some(MissingStrippedStringSkeleton),           ClipboardSnippet::StrippedStringSkeleton(_))           => true,
            (Some(MissingCoreStringSkeleton),               ClipboardSnippet::CoreStringSkeleton(_))               => true,
            (Some(MissingAnnotatedLeafHolderExpansions),    ClipboardSnippet::AnnotatedLeafHolderExpansions(_))    => true,
            _ => false,
        }
    }
}

pub trait ApplyClipboardSnippet {

    fn apply_clipboard_snippet(&mut self, snippet: ClipboardSnippet);
}

impl ApplyClipboardSnippet for PartiallyGrownModel {

    /// Apply the snippet to this partial by setting whichever field is missing
    fn apply_clipboard_snippet(&mut self, snippet: ClipboardSnippet) {
        match snippet {
            ClipboardSnippet::JustifiedGrowerTreeConfiguration(cfg) => {
                self.set_maybe_ungrown_justified_grower_tree_configuration(Some(cfg));
            }
            ClipboardSnippet::JustifiedStringSkeleton(sk) => {
                self.set_maybe_ungrown_justified_string_skeleton(Some(sk));
            }
            ClipboardSnippet::StrippedStringSkeleton(sk) => {
                self.set_maybe_ungrown_stripped_string_skeleton(Some(sk));
            }
            ClipboardSnippet::CoreStringSkeleton(sk) => {
                self.set_maybe_ungrown_core_string_skeleton(Some(sk));
            }
            ClipboardSnippet::AnnotatedLeafHolderExpansions(ann) => {
                self.set_maybe_ungrown_annotated_leaf_holder_expansions(Some(ann));
            }
        }
    }
}

/// Return an integer rank for a missing partial step:
///   0 => partial is not missing anything (fully valid)
///   1 => MissingJustifiedGrowerTreeConfiguration
///   2 => MissingJustifiedStringSkeleton
///   3 => MissingStrippedStringSkeleton
///   4 => MissingCoreStringSkeleton
///   5 => MissingAnnotatedLeafHolderExpansions
pub fn missing_field_rank(missing: &Option<GrowerModelGenerationInvalidPartial>) -> i32 {
    use GrowerModelGenerationInvalidPartial::*;
    match missing {
        None => 0,
        Some(MissingJustifiedGrowerTreeConfiguration) => 1,
        Some(MissingJustifiedStringSkeleton)          => 2,
        Some(MissingStrippedStringSkeleton)           => 3,
        Some(MissingCoreStringSkeleton)               => 4,
        Some(MissingAnnotatedLeafHolderExpansions)    => 5,
    }
}

/// Return a similar rank for each ClipboardSnippet variant:
pub fn snippet_field_rank(snippet: &ClipboardSnippet) -> i32 {
    match snippet {
        ClipboardSnippet::JustifiedGrowerTreeConfiguration(_) => 1,
        ClipboardSnippet::JustifiedStringSkeleton(_)          => 2,
        ClipboardSnippet::StrippedStringSkeleton(_)           => 3,
        ClipboardSnippet::CoreStringSkeleton(_)               => 4,
        ClipboardSnippet::AnnotatedLeafHolderExpansions(_)    => 5,
    }
}