Struct EvaluatorCache 

pub struct EvaluatorCache<R> { /* private fields */ }

A reusable memory buffer for expression evaluation.

When evaluating an expression multiple times (e.g., against different rows in a database), allocating new vectors for every calculation is inefficient. EvaluatorCache holds onto the allocated memory between runs.

Use this to avoid repeated allocations when evaluating the same expression multiple times.

Automatic Invalidation

This struct stores a version UUID of the expression it was last used with. If you pass this cache to evaluate_with on a modified or completely different expression, it will automatically detect the mismatch and clear itself.

Memory & Performance

• Allocations: Reuses internal vectors to minimize heap traffic.
• Cloning: When evaluate_with returns, the final results for the roots are cloned from this cache.
  • If your result type R is large (e.g., a 10MB Bitmap or large Vector), this clone can be expensive.
  • Recommendation: Wrap large results in std::sync::Arc or std::rc::Rc so that cloning is cheap (pointer copy) rather than deep.

Example

use logify::{EvaluatorCache, ExpressionBuilder, Evaluator};

// Setup
let mut cache = EvaluatorCache::new();
let mut solver = Solver;

// Build a simple expression
let builder = ExpressionBuilder::new();
builder.add_root(builder.leaf("A"));
let expr = builder.build();

let dataset = vec!["Row1", "Row2", "Row3"];

// Fast: Reuses the same vectors for every iteration
for item in dataset {
    // In a real scenario, you would update the roots or append expressions each time.
    let result = expr.evaluate_with(&mut solver, &mut cache);
}

Implementations

impl<R> EvaluatorCache<R>

pub fn new() -> Self

Creates a new, empty cache.

pub fn clear(&mut self)

Manually clears the internal buffers and resets the versioning.

Usually not necessary, as evaluate_with handles invalidation automatically.

Trait Implementations

impl<R> Default for EvaluatorCache<R>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, R> Deserialize<'de> for EvaluatorCache<R>

where R: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> Serialize for EvaluatorCache<R>

where R: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.