integrate timestamp service

Author: simonckemper

linkml-service/src/cli/stress_test.rs

@@ -1,5 +1,6 @@
 //! Real stress testing implementation for `LinkML` CLI
 
+use crate::utils::safe_cast::f64_to_usize_saturating;
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -378,7 +379,7 @@ where
             return 0.0;
         }
 
-        let index = ((sorted_latencies.len() - 1) as f64 * percentile) as usize;
+        let index = f64_to_usize_saturating((sorted_latencies.len() - 1) as f64 * percentile);
         sorted_latencies
             .get(index)
             .map_or(0.0, |d| d.as_millis() as f64)

linkml-service/src/generator/excel.rs

@@ -12,6 +12,7 @@
 //! - Rich formatting options
 
 use super::traits::{Generator, GeneratorError, GeneratorResult};
+use crate::utils::safe_cast::usize_to_f64;
 use async_trait::async_trait;
 use linkml_core::prelude::*;
 use rust_xlsxwriter::{
@@ -803,7 +804,7 @@ impl ExcelGenerator {
         match slot.range.as_deref() {
             Some("string") => format!("{} {}", name, index + 1),
             Some("integer") => format!("{}", (index + 1) * 10),
-            Some("float") => format!("{:.2}", (index + 1) as f64 * 3.14),
+            Some("float") => format!("{:.2}", usize_to_f64(index + 1) * 3.14),
             Some("boolean") => if index % 2 == 0 { "TRUE" } else { "FALSE" }.to_string(),
             Some("date") => format!("2024-01-{:02}", index + 1),
             Some("datetime") => format!("2024-01-{:02}T10:00:00", index + 1),

linkml-service/src/generator/java.rs

@@ -3,6 +3,7 @@
 //! This module generates Java classes from `LinkML` schemas with full
 //! validation support and builder patterns.
 
+use crate::utils::safe_cast::f64_to_i64_saturating;
 use linkml_core::{
     error::LinkMLError,
     types::{ClassDefinition, EnumDefinition, PermissibleValue, SchemaDefinition, SlotDefinition}};
@@ -272,13 +273,13 @@ impl JavaGenerator {
 
         if let Some(min) = &slot.minimum_value
             && let Some(num) = min.as_f64() {
-                writeln!(output, "    @Min({})", num as i64)
+                writeln!(output, "    @Min({})", f64_to_i64_saturating(num))
                     .map_err(Self::fmt_error_to_generator_error)?;
             }
 
         if let Some(max) = &slot.maximum_value
             && let Some(num) = max.as_f64() {
-                writeln!(output, "    @Max({})", num as i64)
+                writeln!(output, "    @Max({})", f64_to_i64_saturating(num))
                     .map_err(Self::fmt_error_to_generator_error)?;
             }
 

linkml-service/src/generator/typeql_constraints.rs

@@ -3,6 +3,7 @@
 //! This module provides comprehensive constraint translation from `LinkML` to `TypeQL`,
 //! supporting `TypeDB` 3.0 features including @card, @key, @unique, and regex patterns.
 
+use crate::utils::safe_cast::u64_to_usize_saturating;
 use linkml_core::prelude::*;
 use std::fmt::Write;
 use std::collections::HashMap;
@@ -103,7 +104,7 @@ impl TypeQLConstraintTranslator {
         if slot.multivalued == Some(true) {
             // Check for explicit max cardinality
             if let Some(serde_json::Value::Number(max)) = &slot.maximum_value {
-                max.as_u64().map(|n| n as usize)
+                max.as_u64().map(u64_to_usize_saturating)
             } else {
                 None // Unbounded
             }

linkml-service/src/generator/typeql_relation_analyzer.rs

@@ -4,6 +4,7 @@
 //! to generate optimal `TypeQL` relations, including multi-way relations,
 //! nested relations, and role detection.
 
+use crate::utils::safe_cast::u64_to_usize_saturating;
 use linkml_core::prelude::*;
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
@@ -211,7 +212,7 @@ impl RelationAnalyzer {
         let min = usize::from(slot.required.unwrap_or(false));
         let max = if slot.multivalued.unwrap_or(false) {
             if let Some(Value::Number(max_card)) = &slot.maximum_value {
-                max_card.as_u64().map(|n| n as usize)
+                max_card.as_u64().map(u64_to_usize_saturating)
             } else {
                 None
             }

linkml-service/src/pattern/named_captures.rs

@@ -3,6 +3,7 @@
 //! This module provides advanced named capture functionality for pattern matching,
 //! including type conversion, validation, and extraction utilities.
 
+use crate::utils::safe_cast::i64_to_f64_lossy;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -376,7 +377,7 @@ impl CaptureValue {
     #[must_use] pub fn as_float(&self) -> Option<f64> {
         match self {
             CaptureValue::Float(f) => Some(*f),
-            CaptureValue::Integer(i) => Some(*i as f64),
+            CaptureValue::Integer(i) => Some(i64_to_f64_lossy(*i)),
             _ => None}
     }
 

linkml-service/src/transform/schema_diff.rs

@@ -3,6 +3,7 @@
 //! This module provides functionality to compute differences between `LinkML` schemas,
 //! including structural differences, semantic changes, and breaking change detection.
 
+use crate::utils::safe_cast::usize_to_f64;
 use linkml_core::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
@@ -307,8 +308,8 @@ impl SchemaDiffer {
         // Compare attributes
         let old_attrs: HashSet<_> = old_class.attributes.keys().cloned().collect();
         let new_attrs: HashSet<_> = new_class.attributes.keys().cloned().collect();
-        let attr_intersection = old_attrs.intersection(&new_attrs).count() as f64;
-        let attr_union = old_attrs.union(&new_attrs).count() as f64;
+        let attr_intersection = usize_to_f64(old_attrs.intersection(&new_attrs).count());
+        let attr_union = usize_to_f64(old_attrs.union(&new_attrs).count());
 
         if attr_union > 0.0 {
             score += attr_intersection / attr_union;
@@ -330,8 +331,8 @@ impl SchemaDiffer {
         // Compare mixins
         let old_mixins: HashSet<_> = old_class.mixins.iter().cloned().collect();
         let new_mixins: HashSet<_> = new_class.mixins.iter().cloned().collect();
-        let mixin_intersection = old_mixins.intersection(&new_mixins).count() as f64;
-        let mixin_union = old_mixins.union(&new_mixins).count() as f64;
+        let mixin_intersection = usize_to_f64(old_mixins.intersection(&new_mixins).count());
+        let mixin_union = usize_to_f64(old_mixins.union(&new_mixins).count());
 
         if mixin_union > 0.0 {
             score += mixin_intersection / mixin_union;

linkml-service/src/utils/safe_cast.rs

@@ -135,6 +135,54 @@ pub fn f32_to_usize_saturating(value: f32) -> usize {
     }
 }
 
+/// Safely cast u128 to u64 with saturation
+#[must_use]
+pub fn u128_to_u64_saturating(value: u128) -> u64 {
+    if value > u64::MAX as u128 {
+        u64::MAX
+    } else {
+        value as u64
+    }
+}
+
+/// Safely cast u64 to usize with saturation
+#[must_use]
+pub fn u64_to_usize_saturating(value: u64) -> usize {
+    if value > usize::MAX as u64 {
+        usize::MAX
+    } else {
+        value as usize
+    }
+}
+
+/// Safely cast f64 to i64 with saturation and rounding
+#[must_use]
+pub fn f64_to_i64_saturating(value: f64) -> i64 {
+    if value > i64::MAX as f64 {
+        i64::MAX
+    } else if value < i64::MIN as f64 {
+        i64::MIN
+    } else if value.is_nan() {
+        0
+    } else {
+        value.round() as i64
+    }
+}
+
+/// Safely cast f64 to usize with saturation and rounding
+#[must_use]
+pub fn f64_to_usize_saturating(value: f64) -> usize {
+    if value < 0.0 {
+        0
+    } else if value > usize::MAX as f64 {
+        usize::MAX
+    } else if value.is_nan() {
+        0
+    } else {
+        value.round() as usize
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

linkml-service/src/validator/engine.rs

@@ -1,6 +1,7 @@
 //! Main validation engine
 
 use crate::performance::profiling::Profiler;
+use crate::utils::safe_cast::u128_to_u64_saturating;
 use linkml_core::{
     error::{LinkMLError, Result},
     settings::SchemaSettings,
@@ -747,7 +748,7 @@ impl ValidationEngine {
             .map_err(|e| LinkMLError::service(format!("Failed to get system time: {e}")))?;
         let duration = end.duration_since(start)
             .map_err(|e| LinkMLError::service(format!("Time calculation error: {e}")))?;
-        report.stats.duration_ms = duration.as_millis().min(u64::MAX as u128) as u64;
+        report.stats.duration_ms = u128_to_u64_saturating(duration.as_millis());
         Ok(report)
     }
 

linkml-service/src/validator/resource_limiter.rs

@@ -7,7 +7,7 @@
 //! - Request rate limiting
 //! - Timeout enforcement
 
-use crate::utils::safe_cast::{usize_to_f64, usize_to_f32_saturating};
+use crate::utils::safe_cast::{usize_to_f64, usize_to_f32_saturating, u64_to_usize_saturating};
 use dashmap::DashMap;
 use parking_lot::{Mutex, RwLock};
 use linkml_core::{LinkMLError, Result};
@@ -560,7 +560,7 @@ impl ResourceMonitor for SystemResourceMonitor {
         // Note: sysinfo::System doesn't implement Clone, so we create a new instance
         let mut system = sysinfo::System::new();
         system.refresh_memory();
-        system.used_memory() as usize
+        u64_to_usize_saturating(system.used_memory())
     }
 
     fn get_cpu_usage(&self) -> f32 {