From cffacc4dc4a46b525250772e87fd69a2f1c64dc2 Mon Sep 17 00:00:00 2001
From: Mike Buland <mike@xagasoft.com>
Date: Thu, 11 Jun 2026 11:35:24 -0700
Subject: Split things out, made things easier to use.

CrimError now has several constructors for different cases, so it's
easier to use, using constructors is normalized now.

Value has a load of From implementations now so it's much, much, much
easier to use in practice.
---
 src/context.rs | 124 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 src/context.rs

(limited to 'src/context.rs')

diff --git a/src/context.rs b/src/context.rs
new file mode 100644
index 0000000..78a7940
--- /dev/null
+++ b/src/context.rs
@@ -0,0 +1,124 @@
+use std::collections::HashMap;
+
+use crate::{Identifier,IdentifierValue};
+
+pub type Context = HashMap<String,Value>;
+
+pub trait MappedStructure {
+    fn get_value(&self, id: &Identifier) -> Option<Value>;
+}
+
+impl MappedStructure for Context {
+    fn get_value(&self, id: &Identifier) -> Option<Value> {
+        if id.len() == 0 {
+            return None;
+        }
+        let mut cur_val : Option<&Value> = if let IdentifierValue::Name(s) = &id[0] {
+            self.get(s)
+        } else {
+            return None;
+        };
+        if cur_val.is_none() {
+            return None;
+        }
+
+        for idx in 1..id.len() {
+            if let IdentifierValue::Name(s) = &id[idx] &&
+                let Some(Value::Dictionary(d)) = &cur_val {
+                cur_val.replace( if let Some(v) = d.get(s) {
+                    v
+                } else {
+                    return None;
+                });
+            }
+        }
+
+        return cur_val.cloned();
+    }
+}
+
+#[derive(Debug,Clone)]
+pub enum Value {
+    Dictionary(Context),
+    List(Vec<Value>),
+    String(String),
+    Int(i64),
+    Float(f64),
+    Identifier(Identifier),
+}
+
+impl From<&str> for Value {
+    fn from(val: &str ) -> Value {
+        Value::String(val.into())
+    }
+}
+
+impl From<String> for Value {
+    fn from(val: String) -> Value {
+        Value::String(val)
+    }
+}
+
+impl From<i64> for Value {
+    fn from(val: i64) -> Value {
+        Value::Int(val)
+    }
+}
+
+impl From<f64> for Value {
+    fn from(val: f64) -> Value {
+        Value::Float(val)
+    }
+}
+
+impl From<Vec<Value>> for Value {
+    fn from(val: Vec<Value>) -> Value {
+        Value::List(val)
+    }
+}
+
+impl From<&[Value]> for Value {
+    fn from(val: &[Value]) -> Value {
+        Value::List(Vec::from(val))
+    }
+}
+
+impl From<Context> for Value {
+    fn from(val: Context) -> Value {
+        Value::Dictionary(val)
+    }
+}
+
+impl<const N: usize> From<[(String,Value); N]> for Value {
+    fn from(val: [(String,Value); N]) -> Value {
+        Value::Dictionary(HashMap::from(val))
+    }
+}
+
+/*
+impl MappedStructure for Value {
+    fn get_value(&self, id: &Identifier) -> Option<Value> {
+        if id.len() == 0 {
+            return Some(self);
+        }
+        match Value {
+            Value::Dictionary(dict) => {
+            }
+        }
+        let mut cur_val : Option<&Value> = Some(&self);
+
+        for idx in 0..id.len() {
+            if let IdentifierValue::Name(s) = &id[idx] &&
+                let Some(Value::Dictionary(d)) = &cur_val {
+                cur_val.replace( if let Some(v) = d.get(s) {
+                    v
+                } else {
+                    return None;
+                });
+            }
+        }
+
+        return cur_val.cloned();
+    }
+}
+*/
-- 
cgit v1.2.3