Struct EvalData 

pub struct EvalData { /* private fields */ }

Tracked data wrapper that gates all mutations for safety

Design Philosophy

EvalData serves as the single gatekeeper for all data mutations in the system. All write operations (set, push_to_array, get_mut, etc.) MUST go through this type to ensure proper version tracking and mutation safety.

This design provides:

• Thread-safe mutation tracking via version numbers
• Copy-on-Write (CoW) semantics via Arc for efficient cloning
• Single point of control for all data state changes
• Prevention of untracked mutations that could cause race conditions

CoW Behavior

• Read operations are zero-cost (direct Arc dereference)
• Clone operations are cheap (Arc reference counting)
• First mutation triggers deep clone via Arc::make_mut
• Subsequent mutations on exclusive owner are zero-cost

Implementations

impl EvalData

pub fn new(data: Value) -> Self

Create a new tracked data wrapper

pub fn from_arc(data: Arc<Value>) -> Self

Wrap an existing Arc<Value> without any allocation or deep clone.

Use this when a read-only view of already-Arc’d data is needed (e.g. a batch snapshot in evaluate_internal). Mutations on the returned instance will trigger Arc::make_mut copy-on-write only on the first write.

pub fn with_schema_data_context( evaluated_schema: &Value, input_data: &Value, context_data: &Value, ) -> Self

Initialize eval data with zero-copy references to evaluated_schema, input_data, and context_data This avoids cloning by directly constructing the data structure with borrowed references

pub fn replace_data_and_context( &mut self, input_data: Value, context_data: Value, )

Replace data and context in existing EvalData (for evaluation updates) Uses CoW: replaces Arc, no clone needed if not shared

pub fn instance_id(&self) -> u64

Get the unique instance ID

pub fn data(&self) -> &Value

Get a reference to the underlying data (read-only) Zero-cost access via Arc dereference

pub fn snapshot_data(&self) -> Arc<Value>

Clone a Value without certain keys

pub fn snapshot_data_clone(&self) -> Value

Returns a deep clone of the current data for diffing before it gets replaced

pub fn exclusive_clone(&self) -> Self

Deep-clone into a new, exclusive EvalData (Arc strong count = 1).

Unlike clone() which bumps the Arc reference count (causing Arc::make_mut to reallocate on the first mutation), this copies the inner Value once and wraps it in a fresh Arc. All subsequent set() / push_to_array() calls on the returned instance are zero-cost because the Arc is always exclusive.

pub fn set(&mut self, path: &str, value: Value)

Set a field value and increment version Accepts both dotted notation (user.name) and JSON pointer format (/user/name) Uses CoW: clones data only if shared

pub fn push_to_array(&mut self, path: &str, value: Value)

Append to an array field without full clone (optimized for table building) Accepts both dotted notation (items) and JSON pointer format (/items) Uses CoW: clones data only if shared

pub fn get(&self, path: &str) -> Option<&Value>

Get a field value Accepts both dotted notation (user.name) and JSON pointer format (/user/name)

pub fn get_without_properties(&self, path: &str) -> Option<&Value>

pub fn get_array_element( &self, array_path: &str, index: usize, ) -> Option<&Value>

OPTIMIZED: Fast array element access

pub fn get_mut(&mut self, path: &str) -> Option<&mut Value>

Get a mutable reference to a field value Accepts both dotted notation and JSON pointer format Uses CoW: clones data only if shared Note: Caller must manually increment version after mutation

pub fn get_table_row_mut( &mut self, path: &str, index: usize, ) -> Option<&mut Map<String, Value>>

Get a mutable reference to a table row object at path[index] Accepts both dotted notation and JSON pointer format Uses CoW: clones data only if shared Returns None if path is not an array or row is not an object

pub fn get_table_row_mut_by_segments( &mut self, segments: &[&str], index: usize, ) -> Option<&mut Map<String, Value>>

Get a mutable reference to a table row object using pre-parsed segments This bypasses repetitive JSON pointer string parsing and allocation

pub fn get_values<'a>(&'a self, paths: &'a [String]) -> Vec<Cow<'a, Value>>

Get multiple field values efficiently (for cache key generation) OPTIMIZED: Use batch pointer resolution for better performance

Trait Implementations

impl Clone for EvalData

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<Value> for EvalData

fn from(value: Value) -> Self

Converts to this type from the input type.