Struct SimdDsonProcessor 

pub struct SimdDsonProcessor { /* private fields */ }

SIMD-accelerated DSON processor implementing all DSON traits

Implementations

impl SimdDsonProcessor

pub fn new(replica_id: &str) -> Self

Create a new SIMD DSON processor

pub fn with_schema( replica_id: &str, input_schema: Vec<String>, output_schema: Vec<String>, ) -> Self

Create with schema filtering

pub const fn with_parallel(self, enabled: bool) -> Self

Enable parallel processing

pub const fn is_parallel(&self) -> bool

Check if parallel processing is enabled

impl SimdDsonProcessor

pub fn process_batch_parallel( &self, documents: Vec<String>, ) -> Result<Vec<String>>

Process multiple documents in parallel

Errors

Returns an error if parallel processing is not enabled or if any document fails to process.

pub fn apply_operations_parallel( &mut self, ops: Vec<DsonOperation>, ) -> Result<Vec<Option<MergeConflict>>>

Apply operations in parallel where order-independent

Errors

Returns an error if any operation fails to apply.

pub fn merge_replicas_parallel( &mut self, replica_ops: Vec<(String, Vec<CrdtOperation>)>, _strategy: &MergeStrategy, ) -> Result<Vec<MergeConflict>>

Merge operations from multiple replicas in parallel

Errors

Returns an error if any merge operation fails.

Trait Implementations

impl ArrayOperations for SimdDsonProcessor

fn array_insert( &mut self, path: &str, index: usize, value: OperationValue, ) -> Result<()>

Insert value at index in array at path

fn array_remove(&mut self, path: &str, index: usize) -> Result<()>

Remove element at index from array at path

fn array_replace( &mut self, path: &str, index: usize, value: OperationValue, ) -> Result<()>

Replace element at index in array at path

fn array_len(&self, path: &str) -> Result<usize>

Get array length at path

fn array_build( &mut self, path: &str, elements: Vec<OperationValue>, ) -> Result<()>

Build array from elements

fn array_filter( &mut self, path: &str, predicate: &FilterPredicate, ) -> Result<()>

Filter array elements

fn array_map(&mut self, path: &str, transform: &TransformFunction) -> Result<()>

Map over array elements

fn array_reduce( &mut self, path: &str, initial: OperationValue, reducer: &ReduceFunction, ) -> Result<OperationValue>

Reduce array to single value

impl CrdtMerge for SimdDsonProcessor

fn merge_operation( &mut self, op: CrdtOperation, ) -> Result<Option<MergeConflict>>

Merge a remote operation into local state

fn merge_field( &mut self, path: &str, value: OperationValue, timestamp: u64, strategy: &MergeStrategy, ) -> Result<Option<MergeConflict>>

Merge field with CRDT semantics

fn vector_clock(&self) -> &VectorClock

Get the current vector clock

fn replica_id(&self) -> &str

Get the replica ID

fn resolve_conflict( &mut self, conflict: &MergeConflict, strategy: &MergeStrategy, ) -> Result<OperationValue>

Resolve a conflict using the specified strategy

impl DeltaCrdt for SimdDsonProcessor

type Delta = SimdDelta

Type representing a delta (difference from previous state)

fn generate_delta(&self, since: &VectorClock) -> Self::Delta

Generate delta since given vector clock

fn apply_delta(&mut self, delta: Self::Delta) -> Result<Vec<MergeConflict>>

Apply delta from remote replica

fn compact(&mut self)

Compact/garbage collect old deltas

impl DocumentProcessor for SimdDsonProcessor

fn process(&mut self, input: &str) -> Result<String>

Process input JSON and return transformed output

fn apply_operation(&mut self, op: &DsonOperation) -> Result<()>

Apply a single operation

fn output(&self) -> Result<String>

Generate output from current state

fn apply_operations(&mut self, ops: &[DsonOperation]) -> Result<()>

Apply a batch of operations

impl DsonImplementation for SimdDsonProcessor

fn name(&self) -> &'static str

Implementation name for comparison

fn version(&self) -> &'static str

Implementation version

fn features(&self) -> Vec<&str>

Supported features

fn characteristics(&self) -> ImplementationCharacteristics

Performance characteristics

impl FieldOperations for SimdDsonProcessor

fn field_add(&mut self, path: &str, value: OperationValue) -> Result<()>

Add a field at path with value

fn field_modify(&mut self, path: &str, value: OperationValue) -> Result<()>

Modify existing field at path

fn field_delete(&mut self, path: &str) -> Result<()>

Delete field at path

fn field_read(&self, path: &str) -> Result<Option<OperationValue>>

Read field value at path

fn field_exists(&self, path: &str) -> bool

Check if field exists at path

impl OpBasedCrdt for SimdDsonProcessor

fn prepare(&self, op: &DsonOperation) -> Result<CrdtOperation>

Prepare an operation for broadcast (downstream precondition)

fn effect(&mut self, op: CrdtOperation) -> Result<Option<MergeConflict>>

Effect an operation (apply after delivery)

fn is_causally_ready(&self, op: &CrdtOperation) -> bool

Check if operation is causally ready to be applied

fn buffer_operation(&mut self, op: CrdtOperation)

Buffer operation until causally ready

fn process_buffered(&mut self) -> Result<Vec<MergeConflict>>

Process buffered operations that are now ready

impl SchemaAware for SimdDsonProcessor

fn matches_input_schema(&self, path: &str) -> bool

Check if a path matches the input schema

fn matches_output_schema(&self, path: &str) -> bool

Check if a path matches the output schema

fn input_schema(&self) -> Vec<String>

Get input schema paths

fn output_schema(&self) -> Vec<String>

Get output schema paths