capability-example 0.1.0

A framework for managing skill tree growth and configuration using automated and manual strategies, ideal for AI-driven environments.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

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

impl PartiallyGrownModel {

    /// Attempts to fill the next missing field from the clipboard, stopping after the first attempt.
    #[tracing::instrument(level = "trace", skip_all)]
    pub fn try_filling_next_none_field_from_clipboard(&mut self) -> bool {

        trace!("self={:#?}",self);

        let mut did_fill = false;

        // 1) JustifiedGrowerTreeConfiguration
        if self.maybe_ungrown_justified_grower_tree_configuration().is_none() {
            trace!("attempting parse clipboard as JustifiedGrowerTreeConfiguration");
            match fuzzy_parse_clipboard_contents::<JustifiedGrowerTreeConfiguration>(false) {
                Ok(val) => {
                    trace!("Clipboard provided a valid JustifiedGrowerTreeConfiguration => setting it.");
                    self.set_maybe_ungrown_justified_grower_tree_configuration(Some(val));
                    did_fill = true;
                }
                Err(e) => {
                    warn!("Fuzzy parse for JustifiedGrowerTreeConfiguration from clipboard failed => leaving None. Error: {:?}", e);
                }
            }
            return did_fill;
        }

        // 2) JustifiedStringSkeleton
        if self.maybe_ungrown_justified_string_skeleton().is_none() {
            trace!("attempting parse clipboard as JustifiedStringSkeleton");
            match fuzzy_parse_clipboard_contents::<JustifiedStringSkeleton>(false) {
                Ok(val) => {
                    trace!("Clipboard provided a valid JustifiedStringSkeleton => setting it.");
                    self.set_maybe_ungrown_justified_string_skeleton(Some(val));
                    did_fill = true;
                }
                Err(e) => {
                    warn!("Fuzzy parse for JustifiedStringSkeleton from clipboard failed => leaving None. Error: {:?}", e);
                }
            }
            return did_fill;
        }

        // 3) StrippedStringSkeleton (precise parse)
        if self.maybe_ungrown_stripped_string_skeleton().is_none() {
            trace!("attempting parse clipboard as StrippedStringSkeleton");
            match (|| -> 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 parsing 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 from clipboard: {e}"))
                })?;
                Ok(parsed)
            })() {
                Ok(parsed) => {
                    trace!("Clipboard provided a valid StrippedStringSkeleton => setting it.");
                    self.set_maybe_ungrown_stripped_string_skeleton(Some(parsed));
                    did_fill = true;
                }
                Err(e) => {
                    warn!("Parse for StrippedStringSkeleton from clipboard failed => leaving None. Error: {e}");
                }
            }
            return did_fill;
        }

        // 4) CoreStringSkeleton
        if self.maybe_ungrown_core_string_skeleton().is_none() {
            trace!("attempting parse clipboard as CoreStringSkeleton");
            match fuzzy_parse_clipboard_contents::<CoreStringSkeleton>(false) {
                Ok(val) => {
                    trace!("Clipboard provided a valid CoreStringSkeleton => setting it.");
                    self.set_maybe_ungrown_core_string_skeleton(Some(val));
                    did_fill = true;
                }
                Err(e) => {
                    warn!("Fuzzy parse for CoreStringSkeleton from clipboard failed => leaving None. Error: {:?}", e);
                }
            }
            return did_fill;
        }

        // 5) AnnotatedLeafHolderExpansions
        if self.maybe_ungrown_annotated_leaf_holder_expansions().is_none() {
            trace!("attempting parse clipboard as AnnotatedLeafHolderExpansions");
            match fuzzy_parse_clipboard_contents::<AnnotatedLeafHolderExpansions>(false) {
                Ok(val) => {
                    trace!("Clipboard provided a valid AnnotatedLeafHolderExpansions => setting it.");
                    self.set_maybe_ungrown_annotated_leaf_holder_expansions(Some(val));
                    did_fill = true;
                }
                Err(e) => {
                    warn!("Fuzzy parse for AnnotatedLeafHolderExpansions failed => leaving None. Error: {:?}", e);
                }
            }
            return did_fill;
        }

        trace!("All optional fields are already set; nothing to fill from clipboard.");
        did_fill
    }
}