Feature/stk 3020 upgrade haystack 4

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libhaystack"
-version = "1.0.14"
+version = "2.0.0"
 description = "Rust implementation of the Haystack 4 data types, defs, filter, units, and encodings"
 authors = ["J2 Innovations", "Radu Racariu <[email protected]>"]
 edition = "2021"
@@ -61,8 +61,8 @@ uuid = { version = "1.1", features = ["v4"] }
 chrono = "0.4"
 chrono-tz = "0.6"
 lazy_static = "1.4"
-dashmap = "5.4"
 regex = "1.10.3"
+dashmap = "6.1.0"
 
 [dev-dependencies]
 criterion = "0.3"

src/c_api/datetime.rs

@@ -17,7 +17,7 @@ use std::os::raw::c_char;
 /// - result The Value to be updated with the result DateTime.
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -79,7 +79,7 @@ pub unsafe extern "C" fn haystack_value_get_datetime_date(
 /// - result The Value to be updated with the result Time.
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;

src/c_api/dict.rs

@@ -19,7 +19,7 @@ use crate::{haystack::val::Value, val::List};
 /// # Returns
 /// - number of elements
 /// - -1 if there was an error getting the length, in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -53,7 +53,7 @@ pub unsafe extern "C" fn haystack_value_get_dict_len(val: *const Value) -> usize
 /// - result The Value to be updated with the result Str List.
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -113,7 +113,7 @@ pub unsafe extern "C" fn haystack_value_get_dict_keys(
 /// - entry A [Value](crate::val::Value) to be inserted into the dict
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -170,7 +170,7 @@ pub unsafe extern "C" fn haystack_value_insert_dict_entry(
 /// - result The Value to be updated.
 /// # Returns
 /// - 1 (True) if the operation was successful, 0 (false) if no element found, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -230,7 +230,7 @@ pub unsafe extern "C" fn haystack_value_get_dict_entry(
 /// - key The key to be removed
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;

src/c_api/grid.rs

@@ -43,7 +43,7 @@ pub unsafe extern "C" fn haystack_value_get_grid_len(val: *const Value) -> usize
 /// [Dict](crate::val::Dict) [Value](crate::val::Value)s
 /// # Arguments
 /// - rows List](crate::val::List) [Value](crate::val::Value) of
-/// [Dict](crate::val::Dict) [Value](crate::val::Value)s
+///   [Dict](crate::val::Dict) [Value](crate::val::Value)s
 /// # Returns
 /// - The value pointer
 /// - None if there was an error, in which case use [last_error_message](super::err::last_error_message)
@@ -112,7 +112,7 @@ pub unsafe extern "C" fn haystack_value_make_grid_from_rows(
 /// [Dict](crate::val::Dict) [Value](crate::val::Value)s
 /// # Arguments
 /// - rows a [List](crate::val::List) [Value](crate::val::Value) of
-/// [Dict](crate::val::Dict) [Value](crate::val::Value)s
+///   [Dict](crate::val::Dict) [Value](crate::val::Value)s
 /// # Returns
 /// - The value pointer
 /// - None if there was an error, in which case use [last_error_message](super::err::last_error_message)

src/c_api/list.rs

@@ -46,7 +46,7 @@ pub unsafe extern "C" fn haystack_value_get_list_len(val: *mut Value) -> usize {
 /// - entry A [Value](crate::val::Value) to be inserted into the list
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -92,7 +92,7 @@ pub unsafe extern "C" fn haystack_value_push_list_entry(
 /// - result The Value to be updated with the result.
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -146,7 +146,7 @@ pub unsafe extern "C" fn haystack_value_get_list_entry_at(
 /// - element  A  [Value](crate::val::Value)
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;
@@ -206,7 +206,7 @@ pub unsafe extern "C" fn haystack_value_set_list_entry_at(
 /// - index The index were to inset the value at
 /// # Returns
 /// - 1 (True) if the operation was successful, -1 otherwise in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;

src/c_api/number.rs

@@ -49,7 +49,7 @@ pub unsafe extern "C" fn haystack_value_get_number_value(val: *const Value) -> f
 /// # Returns
 /// - 1 if has unit, 0 otherwise
 /// - -1 if there was an error, in which case the [last_error_message](super::err::last_error_message)
-/// can be called to get the error message.
+///   can be called to get the error message.
 /// # Example
 /// ```rust
 /// # use crate::libhaystack::val::Value;

src/haystack/defs/namespace.rs

@@ -257,7 +257,7 @@ impl<'a> Namespace<'a> {
     }
 
     ///  Returns the supertypes of a def or an empty list if it can't be found.
-    pub fn supertypes_of(&'a self, symbol: &Symbol) -> MapReadRef<Symbol, Vec<&'a Dict>> {
+    pub fn supertypes_of(&'a self, symbol: &Symbol) -> MapReadRef<'a, Symbol, Vec<&'a Dict>> {
         if let Some(super_types) = self.supertypes_of_cache.get(symbol) {
             super_types
         } else {
@@ -315,8 +315,8 @@ impl<'a> Namespace<'a> {
 
     /// Returns a list of choices for def.
     pub fn choices_for(&self, symbol: &Symbol) -> &Vec<Dict> {
-        if let Some(of) = self.get(symbol).and_then(|def| def.get_symbol("of")) {
-            self.subtypes_of(of)
+        if self.get(symbol).is_some_and(|def| self.is_choice(def)) {
+            self.subtypes_of(symbol)
         } else {
             &EMPTY_VEC_DICT
         }
@@ -326,13 +326,21 @@ impl<'a> Namespace<'a> {
     /// all defs that are choices.
     fn compute_choices(&mut self) {
         for (sym, def) in &self.defs {
-            if def.get_symbol("of").is_some() {
+            // A choice extends directly from 'choice'.
+            if self.is_choice(def) {
                 self.choices
                     .insert(sym.clone(), self.choices_for(sym).clone());
             }
         }
     }
 
+    fn is_choice(&self, def: &Dict) -> bool {
+        def.get_list("is")
+            .into_iter()
+            .flatten()
+            .any(|v| v == &Value::make_symbol("choice"))
+    }
+
     /// Compute a list of the features names.
     fn compute_feature_names(&mut self) {
         let mut features = HashSet::<&str>::new();
@@ -386,7 +394,7 @@ impl<'a> Namespace<'a> {
     }
 
     /// Return the defs inheritance as a flattened array of defs.
-    pub fn inheritance(&'a self, symbol: &Symbol) -> MapReadRef<Symbol, Vec<&'a Dict>> {
+    pub fn inheritance(&'a self, symbol: &Symbol) -> MapReadRef<'a, Symbol, Vec<&'a Dict>> {
         if let Some(inheritance) = self.inheritance_of_cache.get(symbol) {
             inheritance
         } else {
@@ -410,7 +418,7 @@ impl<'a> Namespace<'a> {
     /// - parent The parent def.
     /// - association The association.
     ///
-    pub fn associations(&'a self, parent: &Symbol, association: &Symbol) -> Vec<&Dict> {
+    pub fn associations(&'a self, parent: &Symbol, association: &Symbol) -> Vec<&'a Dict> {
         if let Some(association_def) = self.get(association) {
             // Make sure the association exists and is an association.
             if matches!(
@@ -424,7 +432,7 @@ impl<'a> Namespace<'a> {
 
             // If the association isn't computed then just get the associated defs.
             // For instance, this will return here if the association is 'tagOn'.
-            if !association_def.has("computed") {
+            if !association_def.has("computedFromReciprocal") {
                 return self
                     .get(parent)
                     .and_then(|def| def.get_list(&association.value))
@@ -457,7 +465,7 @@ impl<'a> Namespace<'a> {
         &'a self,
         parent: &Symbol,
         reciprocal_of: &Symbol,
-    ) -> Vec<&Dict> {
+    ) -> Vec<&'a Dict> {
         let inheritance = self.inheritance(parent);
 
         let mut matches = HashSet::<&Dict>::new();
@@ -484,7 +492,7 @@ impl<'a> Namespace<'a> {
     /// - parent The parent def
     /// # Return
     /// The `is` association defs
-    pub fn is(&'a self, parent: &Symbol) -> Vec<&Dict> {
+    pub fn is(&'a self, parent: &Symbol) -> Vec<&'a Dict> {
         self.associations(parent, &Symbol::from("is"))
     }
 
@@ -493,7 +501,7 @@ impl<'a> Namespace<'a> {
     /// - parent The parent def
     /// # Return
     /// The `tagOn` association defs
-    pub fn tag_on(&'a self, parent: &Symbol) -> Vec<&Dict> {
+    pub fn tag_on(&'a self, parent: &Symbol) -> Vec<&'a Dict> {
         self.associations(parent, &Symbol::from("tagOn"))
     }
 
@@ -502,7 +510,7 @@ impl<'a> Namespace<'a> {
     /// - parent The parent def
     /// # Return
     /// The `tags` association defs
-    pub fn tags(&'a self, parent: &Symbol) -> Vec<&Dict> {
+    pub fn tags(&'a self, parent: &Symbol) -> Vec<&'a Dict> {
         self.associations(parent, &Symbol::from("tags"))
     }
 
@@ -511,7 +519,7 @@ impl<'a> Namespace<'a> {
     /// - subject The subject to reflect
     /// # Return
     /// The reflected defs
-    pub fn reflect(&'a self, subject: &Dict) -> Reflection {
+    pub fn reflect<'b>(&'a self, subject: &'b Dict) -> Reflection<'a> {
         let mut defs = Vec::<&Dict>::new();
         let mut markers = HashSet::<&str>::new();
 
@@ -698,11 +706,10 @@ impl<'a> Namespace<'a> {
     pub fn protos(&'a self, parent: &Dict) -> Vec<Dict> {
         parent
             .keys()
-            .map(|name| self.protos_from_def(parent, name))
-            .fold(Vec::new(), |mut vec, cur| {
-                vec.extend(cur);
-                vec
-            })
+            .flat_map(|name| self.protos_from_def(parent, name))
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .collect()
     }
 
     /// Return a reflected list of children prototypes for the parent dict.

src/haystack/encoding/zinc/decode/complex/grid.rs

@@ -7,13 +7,6 @@ use super::dict::parse_dict_parts;
 use crate::haystack::val::{Column, Dict, Grid, Value};
 use std::io::{Error, Read};
 
-// Zinc [Grid](crate::val::Grid) meta
-#[derive(PartialEq, PartialOrd, Clone, Debug)]
-struct GridMeta {
-    ver: String,
-    meta: Option<Dict>,
-}
-
 /// Parses a Zinc [Grid](crate::val::Grid)
 /// # Arguments
 /// - a generic ParserType

src/haystack/encoding/zinc/decode/id.rs

@@ -3,6 +3,7 @@
 //! Zinc identifier decoding
 
 use super::scanner::Scanner;
+use std::fmt::Display;
 use std::io::{Error, Read};
 use std::string::ToString;
 
@@ -21,9 +22,9 @@ impl From<&str> for Id {
     }
 }
 
-impl ToString for Id {
-    fn to_string(&self) -> String {
-        self.value.clone()
+impl Display for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.value.clone())
     }
 }
 

src/haystack/encoding/zinc/decode/lexer.rs

@@ -246,7 +246,7 @@ impl<'a, R: Read> Lexer<Scanner<'a, R>> {
     }
 }
 
-impl<'a, R: Read> Iterator for Lexer<Scanner<'a, R>> {
+impl<R: Read> Iterator for Lexer<Scanner<'_, R>> {
     type Item = Result<LexerToken, Error>;
 
     fn next(&mut self) -> Option<Self::Item> {

src/haystack/encoding/zinc/decode/parser.rs

@@ -17,9 +17,9 @@ pub struct Parser<Lexer> {
     pub(super) lexer: Lexer,
 }
 
-impl<'a, 'b: 'a, R: Read> Parser<Lexer<Scanner<'b, R>>> {
+impl<'a, R: Read> Parser<Lexer<Scanner<'a, R>>> {
     /// Constructs a [Parser](self::Parser) for the provided [Read](std::io::Read)
-    pub fn make(input: &'b mut R) -> Result<Self, Error> {
+    pub fn make(input: &'a mut R) -> Result<Self, Error> {
         let mut lexer = Lexer::make(input)?;
         // Advance lexer to first token
         lexer.read()?;

src/haystack/filter/eval.rs

@@ -14,7 +14,7 @@ pub trait Eval {
     /// # Arguments
     /// * `dict` - the Dict to match the Filter against
     /// * `resolver` - a generic `PathResolver` that resolves `Path`s
-    /// indirection specified in the `Filter`
+    ///   indirection specified in the `Filter`
     fn eval<R: PathResolver>(&self, context: &EvalContext<R>) -> bool;
 }
 
@@ -34,7 +34,7 @@ impl<'a, 'b: 'a, R: PathResolver> EvalContext<'a, 'b, R> {
     /// * `dict` - the Dict to match the Filter against
     /// * `ns` - the Def namespace to match symbol definitions against
     /// * `resolver` - a generic `PathResolver` that resolves `Path`s
-    /// indirection specified in the `Filter`
+    ///   indirection specified in the `Filter`
     pub fn make(dict: &'a Dict, ns: &'b Namespace<'b>, resolver: &'a R) -> Self {
         Self { dict, ns, resolver }
     }