Struct Workflow 

pub struct Workflow {
    pub id: String,
    pub name: String,
    pub priority: u32,
    pub description: Option<String>,
    pub condition: Value,
    pub condition_index: Option<usize>,
    pub tasks: Vec<Task>,
}

Workflow represents a collection of tasks that execute sequentially

Fields

id: String

name: String

priority: u32

description: Option<String>

condition: Value

condition_index: Option<usize>

tasks: Vec<Task>

Implementations

impl Workflow

pub fn new() -> Self

pub fn from_json(json_str: &str) -> Result<Self>

Load workflow from JSON string

Examples found in repository

examples/complete_workflow.rs (line 112)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Define a workflow that:
    // 1. Prepares sample user data
    // 2. Enriches the message with transformed data
    // 3. Validates the enriched data
    let workflow_json = r#"
    {
        "id": "complete_workflow",
        "name": "Complete Workflow Example",
        "priority": 0,
        "description": "Demonstrates enrich -> validate flow",
        "tasks": [
            {
                "id": "initialize_user",
                "name": "Initialize User Structure",
                "description": "Create empty user object in data",
                "function": {
                    "name": "map",
                    "input": {
                        "mappings": [
                            {
                                "path": "data.user",
                                "logic": {}
                            }
                        ]
                    }
                }
            },
            {
                "id": "transform_data",
                "name": "Transform Data",
                "description": "Map API response to our data model",
                "function": {
                    "name": "map",
                    "input": {
                        "mappings": [
                            {
                                "path": "data.user.id", 
                                "logic": { "var": "temp_data.body.id" }
                            },
                            {
                                "path": "data.user.name", 
                                "logic": { "var": "temp_data.body.name" }
                            },
                            {
                                "path": "data.user.email", 
                                "logic": { "var": "temp_data.body.email" }
                            },
                            {
                                "path": "data.user.address", 
                                "logic": {
                                    "cat": [
                                        { "var": "temp_data.body.address.street" },
                                        ", ",
                                        { "var": "temp_data.body.address.city" }
                                    ]
                                }
                            },
                            {
                                "path": "data.user.company", 
                                "logic": { "var": "temp_data.body.company.name" }
                            }
                        ]
                    }
                }
            },
            {
                "id": "validate_user_data",
                "name": "Validate User Data",
                "description": "Ensure the user data meets our requirements",
                "function": {
                    "name": "validate",
                    "input": {
                        "rules": [
                            {
                                "path": "data",
                                "logic": { "!!": { "var": "data.user.id" } },
                                "message": "User ID is required"
                            },
                            {
                                "path": "data",
                                "logic": { "!!": { "var": "data.user.name" } },
                                "message": "User name is required"
                            },
                            {
                                "path": "data",
                                "logic": { "!!": { "var": "data.user.email" } },
                                "message": "User email is required"
                            },
                            {
                                "path": "data",
                                "logic": {
                                    "in": [
                                        "@",
                                        { "var": "data.user.email" }
                                    ]
                                },
                                "message": "Email must be valid format"
                            }
                        ]
                    }
                }
            }
        ]
    }
    "#;

    // Parse the workflow
    let workflow = Workflow::from_json(workflow_json)?;

    // Create the workflow engine with the workflow (built-in functions are auto-registered by default)
    let mut engine = Engine::new(vec![workflow], None, None);

    // Create a message to process with sample user data
    let mut message = Message::new(&json!({}));

    // Add sample user data to temp_data (simulating what would come from an API)
    message.temp_data = json!({
        "body": {
            "id": 1,
            "name": "John Doe",
            "email": "john.doe@example.com",
            "address": {
                "street": "123 Main St",
                "city": "New York"
            },
            "company": {
                "name": "Acme Corp"
            }
        }
    });

    // Process the message through the workflow
    println!("Processing message through workflow...");

    match engine.process_message(&mut message) {
        Ok(_) => {
            println!("Workflow completed successfully!");
        }
        Err(e) => {
            eprintln!("Error executing workflow: {e:?}");
            if !message.errors.is_empty() {
                println!("\nErrors recorded in message:");
                for err in &message.errors {
                    println!(
                        "- Workflow: {:?}, Task: {:?}, Error: {:?}",
                        err.workflow_id, err.task_id, err.error_message
                    );
                }
            }
        }
    }

    println!(
        "\nFull message structure:\n{}",
        serde_json::to_string_pretty(&message)?
    );

    Ok(())
}

examples/benchmark.rs (line 89)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("========================================");
    println!("DATAFLOW ENGINE BENCHMARK");
    println!("========================================\n");
    println!(
        "Running {} iterations on single-threaded engine\n",
        ITERATIONS
    );

    // Define a simple workflow with data transformation
    let workflow_json = r#"
    {
        "id": "benchmark_workflow",
        "name": "Benchmark Workflow",
        "description": "Simple workflow for performance testing",
        "priority": 1,
        "tasks": [
            {
                "id": "transform_data",
                "name": "Transform Data",
                "description": "Map data fields",
                "function": {
                    "name": "map",
                    "input": {
                        "mappings": [
                            {
                                "path": "data.user.id", 
                                "logic": { "var": "temp_data.id" }
                            },
                            {
                                "path": "data.user.name", 
                                "logic": { "var": "temp_data.name" }
                            },
                            {
                                "path": "data.user.email", 
                                "logic": { "var": "temp_data.email" }
                            },
                            {
                                "path": "data.user.age",
                                "logic": { "+": [{ "var": "temp_data.age" }, 1] }
                            },
                            {
                                "path": "data.user.status",
                                "logic": { 
                                    "if": [
                                        { ">": [{ "var": "temp_data.age" }, 18] },
                                        "adult",
                                        "minor"
                                    ]
                                }
                            }
                        ]
                    }
                }
            },
            {
                "id": "validate_data",
                "name": "Validate Data",
                "description": "Validate transformed data",
                "function": {
                    "name": "validate",
                    "input": {
                        "rules": [
                            {
                                "path": "data",
                                "logic": { "!!": { "var": "data.user.id" } },
                                "message": "User ID is required"
                            },
                            {
                                "path": "data",
                                "logic": { "!!": { "var": "data.user.email" } },
                                "message": "User email is required"
                            }
                        ]
                    }
                }
            }
        ]
    }
    "#;

    // Parse the workflow
    let workflow = Workflow::from_json(workflow_json)?;

    // Create the engine with built-in functions
    let mut engine = Engine::new(vec![workflow], None, None);

    // Sample data for benchmarking
    let sample_data = json!({
        "id": 12345,
        "name": "John Doe",
        "email": "john.doe@example.com",
        "age": 25,
        "department": "Engineering"
    });

    // Warm-up run
    println!("Warming up...");
    for _ in 0..1000 {
        let mut message = Message::new(&json!({}));
        message.temp_data = sample_data.clone();
        let _ = engine.process_message(&mut message);
    }

    // Benchmark run
    println!("Starting benchmark...\n");

    let mut all_durations = Vec::with_capacity(ITERATIONS);
    let mut success_count = 0;
    let mut error_count = 0;

    let benchmark_start = Instant::now();

    for i in 0..ITERATIONS {
        let mut message = Message::new(&json!({}));
        message.temp_data = sample_data.clone();
        message.metadata = json!({
            "iteration": i,
            "timestamp": chrono::Utc::now().to_rfc3339()
        });

        let iteration_start = Instant::now();
        match engine.process_message(&mut message) {
            Ok(_) => {
                success_count += 1;
                if message.has_errors() {
                    error_count += 1;
                }
            }
            Err(_) => {
                error_count += 1;
            }
        }
        let iteration_duration = iteration_start.elapsed();
        all_durations.push(iteration_duration);

        // Progress indicator every 10k iterations
        if (i + 1) % 10000 == 0 {
            print!(".");
            use std::io::Write;
            std::io::stdout().flush()?;
        }
    }

    let total_time = benchmark_start.elapsed();
    println!("\n\nBenchmark Complete!");
    println!("==========================================\n");

    // Calculate statistics
    all_durations.sort_unstable();
    let p50 = all_durations[ITERATIONS * 50 / 100];
    let p90 = all_durations[ITERATIONS * 90 / 100];
    let p95 = all_durations[ITERATIONS * 95 / 100];
    let p99 = all_durations[ITERATIONS * 99 / 100];
    let throughput = ITERATIONS as f64 / total_time.as_secs_f64();

    // Display results
    println!("📊 PERFORMANCE METRICS");
    println!("──────────────────────────────────────────");
    println!("Total iterations:    {:>10}", ITERATIONS);
    println!("Successful:          {:>10}", success_count);
    println!("Errors:              {:>10}", error_count);
    println!(
        "Total time:          {:>10.3} seconds",
        total_time.as_secs_f64()
    );
    println!();

    println!("Messages/second:     {:>10.0}", throughput);
    println!();

    println!("📉 LATENCY PERCENTILES");
    println!("──────────────────────────────────────────");
    println!("P50:                 {:>10.3} μs", p50.as_micros() as f64);
    println!("P90:                 {:>10.3} μs", p90.as_micros() as f64);
    println!("P95:                 {:>10.3} μs", p95.as_micros() as f64);
    println!("P99:                 {:>10.3} μs", p99.as_micros() as f64);
    println!();

    Ok(())
}

examples/custom_function.rs (line 394)

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("=== Custom Function Example ===\n");

    // Define a workflow that uses our custom functions
    let workflow_json = r#"
    {
        "id": "custom_function_demo",
        "name": "Custom Function Demo",
        "description": "Demonstrates custom functions in workflow",
        "tasks": [
            {
                "id": "prepare_data",
                "name": "Prepare Data",
                "description": "Extract and prepare data for analysis",
                "function": {
                    "name": "map",
                    "input": {
                        "mappings": [
                            {
                                "path": "data.numbers",
                                "logic": { "var": "temp_data.measurements" }
                            },
                            {
                                "path": "data.user_id",
                                "logic": { "var": "temp_data.user_id" }
                            }
                        ]
                    }
                }
            },
            {
                "id": "calculate_stats",
                "name": "Calculate Statistics",
                "description": "Calculate statistical measures from numeric data",
                "function": {
                    "name": "statistics",
                    "input": {
                        "data_path": "data.numbers",
                        "output_path": "data.stats"
                    }
                }
            },
            {
                "id": "enrich_user_data",
                "name": "Enrich User Data",
                "description": "Add additional user information",
                "function": {
                    "name": "enrich_data",
                    "input": {
                        "lookup_field": "user_id",
                        "lookup_value": "user_123",
                        "output_path": "data.user_info"
                    }
                }
            }
        ]
    }
    "#;

    // Parse the first workflow
    let workflow = Workflow::from_json(workflow_json)?;

    // Demonstrate another example with different data
    let separator = "=".repeat(50);
    println!("\n{separator}");
    println!("=== Second Example with Different User ===\n");

    let mut message2 = dataflow_rs::engine::message::Message::new(&json!({}));
    message2.temp_data = json!({
        "measurements": [5.1, 7.3, 9.8, 6.2, 8.5],
        "user_id": "user_456",
        "timestamp": "2024-01-15T11:00:00Z"
    });
    message2.data = json!({});

    // Create a workflow for the second user
    let workflow2_json = r#"
    {
        "id": "custom_function_demo_2",
        "name": "Custom Function Demo 2",
        "description": "Second demo with different user",
        "tasks": [
            {
                "id": "prepare_data",
                "name": "Prepare Data",
                "function": {
                    "name": "map",
                    "input": {
                        "mappings": [
                            {
                                "path": "data.numbers",
                                "logic": { "var": "temp_data.measurements" }
                            },
                            {
                                "path": "data.user_id",
                                "logic": { "var": "temp_data.user_id" }
                            }
                        ]
                    }
                }
            },
            {
                "id": "calculate_stats",
                "name": "Calculate Statistics",
                "function": {
                    "name": "statistics",
                    "input": {
                        "data_path": "data.numbers",
                        "output_path": "data.analysis"
                    }
                }
            },
            {
                "id": "enrich_user_data",
                "name": "Enrich User Data",
                "function": {
                    "name": "enrich_data",
                    "input": {
                        "lookup_field": "user_id",
                        "lookup_value": "user_456",
                        "output_path": "data.employee_details"
                    }
                }
            }
        ]
    }
    "#;

    let workflow2 = Workflow::from_json(workflow2_json)?;

    // Prepare custom functions
    let mut custom_functions = HashMap::new();
    custom_functions.insert(
        "statistics".to_string(),
        Box::new(StatisticsFunction::new()) as Box<dyn FunctionHandler + Send + Sync>,
    );
    custom_functions.insert(
        "enrich_data".to_string(),
        Box::new(DataEnrichmentFunction::new()) as Box<dyn FunctionHandler + Send + Sync>,
    );
    // Note: map and validate are now built-in to the Engine and will be used automatically

    // Create engine with custom functions and built-ins (map/validate are always included internally)
    let mut engine = Engine::new(
        vec![workflow, workflow2],
        Some(custom_functions),
        None, // Use default (includes built-ins)
    );

    // Create sample data for first message
    let sample_data = json!({
        "measurements": [10.5, 15.2, 8.7, 22.1, 18.9, 12.3, 25.6, 14.8, 19.4, 16.7],
        "user_id": "user_123",
        "timestamp": "2024-01-15T10:30:00Z"
    });

    // Create and process first message
    let mut message = dataflow_rs::engine::message::Message::new(&json!({}));
    message.temp_data = sample_data;
    message.data = json!({});

    println!("Processing message with custom functions...\n");

    // Process the message through our custom workflow
    match engine.process_message(&mut message) {
        Ok(_) => {
            println!("✅ Message processed successfully!\n");

            println!("📊 Final Results:");
            println!("{}\n", serde_json::to_string_pretty(&message.data)?);

            println!("📋 Audit Trail:");
            for (i, audit) in message.audit_trail.iter().enumerate() {
                println!(
                    "{}. Task: {} (Status: {})",
                    i + 1,
                    audit.task_id,
                    audit.status_code
                );
                println!("   Timestamp: {}", audit.timestamp);
                println!("   Changes: {} field(s) modified", audit.changes.len());
            }

            if message.has_errors() {
                println!("\n⚠️  Errors encountered:");
                for error in &message.errors {
                    println!(
                        "   - {}: {:?}",
                        error.task_id.as_ref().unwrap_or(&"unknown".to_string()),
                        error.error_message
                    );
                }
            }
        }
        Err(e) => {
            println!("❌ Error processing message: {e:?}");
        }
    }

    // Process second message
    match engine.process_message(&mut message2) {
        Ok(_) => {
            println!("✅ Second message processed successfully!\n");
            println!("📊 Results for user_456:");
            println!("{}", serde_json::to_string_pretty(&message2.data)?);
        }
        Err(e) => {
            println!("❌ Error processing second message: {e:?}");
        }
    }

    println!("\n🎉 Custom function examples completed!");

    Ok(())
}

examples/memory_leak_analysis.rs (line 190)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("========================================");
    println!("MEMORY LEAK ANALYSIS");
    println!("========================================\n");
    println!("Warmup iterations: {}", WARMUP_ITERATIONS);
    println!("Test iterations: {}", TEST_ITERATIONS);
    println!("Sample interval: every {} iterations\n", SAMPLE_INTERVAL);

    // Define a workflow with memory-intensive operations
    let workflow_json = r#"
    {
        "id": "memory_test_workflow",
        "name": "Memory Test Workflow",
        "description": "Workflow for memory leak detection",
        "priority": 1,
        "tasks": [
            {
                "id": "transform_data",
                "name": "Transform Data",
                "description": "Map and transform data fields",
                "function": {
                    "name": "map",
                    "input": {
                        "mappings": [
                            {
                                "path": "data.processed.id", 
                                "logic": { "var": "temp_data.id" }
                            },
                            {
                                "path": "data.processed.name", 
                                "logic": { "var": "temp_data.name" }
                            },
                            {
                                "path": "data.processed.email", 
                                "logic": { "var": "temp_data.email" }
                            },
                            {
                                "path": "data.processed.large_text",
                                "logic": { "var": "temp_data.large_text_field" }
                            },
                            {
                                "path": "data.processed.description",
                                "logic": { "var": "temp_data.description" }
                            },
                            {
                                "path": "data.processed.computed",
                                "logic": { 
                                    "cat": [
                                        { "var": "temp_data.name" },
                                        " - ",
                                        { "var": "temp_data.department" },
                                        " - ",
                                        { "var": "temp_data.id" },
                                        " - ",
                                        { "var": "temp_data.description" }
                                    ]
                                }
                            },
                            {
                                "path": "data.processed.tags",
                                "logic": {
                                    "map": [
                                        { "var": "temp_data.tags" },
                                        {
                                            "cat": [
                                                "processed_tag_",
                                                { "var": "" },
                                                "_with_suffix"
                                            ]
                                        }
                                    ]
                                }
                            },
                            {
                                "path": "data.processed.nested_objects",
                                "logic": { "var": "temp_data.nested_objects" }
                            },
                            {
                                "path": "data.processed.binary_data",
                                "logic": { "var": "temp_data.binary_data" }
                            },
                            {
                                "path": "data.processed.floats",
                                "logic": { "var": "temp_data.floats" }
                            },
                            {
                                "path": "data.processed.additional_fields",
                                "logic": { "var": "temp_data.additional_fields" }
                            },
                            {
                                "path": "data.processed.metadata",
                                "logic": { "var": "temp_data.metadata" }
                            }
                        ]
                    }
                }
            },
            {
                "id": "validate_data",
                "name": "Validate Data",
                "description": "Validate transformed data",
                "function": {
                    "name": "validate",
                    "input": {
                        "rules": [
                            {
                                "path": "data",
                                "logic": { "!!" : { "var": "data.processed.id" } },
                                "message": "ID is required"
                            },
                            {
                                "path": "data",
                                "logic": { "!!" : { "var": "data.processed.email" } },
                                "message": "Email is required"
                            },
                            {
                                "path": "data",
                                "logic": { "!!" : { "var": "data.processed.tags" } },
                                "message": "Tags are required"
                            },
                            {
                                "path": "data",
                                "logic": { "!!" : { "var": "data.processed.nested_objects" } },
                                "message": "Nested objects are required"
                            }
                        ]
                    }
                }
            }
        ]
    }
    "#;

    // Parse the workflow
    let workflow = Workflow::from_json(workflow_json)?;

    // Create the engine
    let mut engine = Engine::new(vec![workflow], None, None);

    // Create large sample data to make memory leaks more visible
    let large_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(100);
    let large_array: Vec<String> = (0..1000)
        .map(|i| format!("item_{}_with_some_longer_text_content", i))
        .collect();
    let nested_objects: Vec<serde_json::Value> = (0..100).map(|i| {
        json!({
            "id": i,
            "name": format!("Object {}", i),
            "description": format!("This is a description for object {} with some additional text", i),
            "attributes": {
                "color": format!("color_{}", i),
                "size": format!("size_{}", i),
                "weight": i * 100,
                "metadata": {
                    "created": "2024-01-01T00:00:00Z",
                    "modified": "2024-01-01T00:00:00Z",
                    "version": i
                }
            },
            "tags": vec![format!("tag_{}", i), format!("category_{}", i % 10), format!("type_{}", i % 5)]
        })
    }).collect();

    let sample_data = json!({
        "id": 12345,
        "name": "John Doe",
        "email": "john.doe@example.com",
        "age": 25,
        "department": "Engineering",
        "description": large_text.clone(),
        "large_text_field": large_text,
        "tags": large_array,
        "nested_objects": nested_objects,
        "metadata": {
            "created": "2024-01-01T00:00:00Z",
            "updated": "2024-01-01T00:00:00Z",
            "complex_data": {
                "level1": {
                    "level2": {
                        "level3": {
                            "data": (0..100).map(|i| format!("nested_value_{}", i)).collect::<Vec<_>>()
                        }
                    }
                }
            }
        },
        "binary_data": (0..10000).map(|i| i % 256).collect::<Vec<u32>>(),
        "floats": (0..1000).map(|i| i as f64 * 3.14159).collect::<Vec<f64>>(),
        "additional_fields": (0..50).map(|i| {
            (format!("field_{}", i), format!("value_{}_with_additional_content", i))
        }).collect::<std::collections::HashMap<_, _>>()
    });

    // Memory tracking
    let initial_memory = get_current_memory();
    println!("Initial memory usage: {}", format_bytes(initial_memory));

    // Warmup phase
    println!("\n📊 WARMUP PHASE");
    println!("──────────────────────────────────────────");
    let warmup_start = Instant::now();
    let warmup_initial_memory = get_current_memory();

    for i in 0..WARMUP_ITERATIONS {
        let mut message = Message::new(&json!({}));
        message.temp_data = sample_data.clone();
        message.metadata = json!({
            "iteration": i,
            "phase": "warmup"
        });

        let _ = engine.process_message(&mut message);

        if (i + 1) % 1000 == 0 {
            print!(".");
            use std::io::Write;
            std::io::stdout().flush()?;
        }
    }

    let warmup_duration = warmup_start.elapsed();
    let warmup_final_memory = get_current_memory();
    let warmup_memory_growth = warmup_final_memory - warmup_initial_memory;

    println!("\n");
    println!(
        "Warmup complete in: {:.2} seconds",
        warmup_duration.as_secs_f64()
    );
    println!("Memory after warmup: {}", format_bytes(warmup_final_memory));
    println!(
        "Memory growth during warmup: {}",
        format_bytes(warmup_memory_growth)
    );

    // Give time for any deferred deallocations
    std::thread::sleep(std::time::Duration::from_millis(100));

    // Test phase - looking for memory leaks
    println!("\n📊 MEMORY LEAK TEST PHASE");
    println!("──────────────────────────────────────────");
    let test_start = Instant::now();
    let test_initial_memory = get_current_memory();
    let mut memory_samples: Vec<(usize, isize)> = Vec::new();
    let mut max_memory = test_initial_memory;
    let mut min_memory = test_initial_memory;

    println!("Starting memory: {}", format_bytes(test_initial_memory));
    println!("\nRunning iterations...");

    for i in 0..TEST_ITERATIONS {
        let mut message = Message::new(&json!({}));
        message.temp_data = sample_data.clone();
        message.metadata = json!({
            "iteration": i,
            "phase": "test",
            "timestamp": chrono::Utc::now().to_rfc3339()
        });

        match engine.process_message(&mut message) {
            Ok(_) => {}
            Err(e) => {
                eprintln!("Error at iteration {}: {:?}", i, e);
            }
        }

        // Sample memory usage periodically
        if (i + 1) % SAMPLE_INTERVAL == 0 {
            let current_memory = get_current_memory();
            memory_samples.push((i + 1, current_memory));
            max_memory = max_memory.max(current_memory);
            min_memory = min_memory.min(current_memory);

            let memory_diff = current_memory - test_initial_memory;
            println!(
                "Iteration {:6}: Memory = {} (Δ = {})",
                i + 1,
                format_bytes(current_memory),
                format_bytes(memory_diff)
            );
        }
    }

    let test_duration = test_start.elapsed();
    let test_final_memory = get_current_memory();
    let test_memory_growth = test_final_memory - test_initial_memory;

    println!("\n========================================");
    println!("📈 ANALYSIS RESULTS");
    println!("========================================\n");

    println!("Test Duration: {:.2} seconds", test_duration.as_secs_f64());
    println!(
        "Iterations/second: {:.0}",
        TEST_ITERATIONS as f64 / test_duration.as_secs_f64()
    );
    println!();

    println!("MEMORY STATISTICS:");
    println!("──────────────────────────────────────────");
    println!(
        "Initial memory (after warmup): {}",
        format_bytes(test_initial_memory)
    );
    println!("Final memory: {}", format_bytes(test_final_memory));
    println!("Memory growth: {}", format_bytes(test_memory_growth));
    println!("Peak memory: {}", format_bytes(max_memory));
    println!("Minimum memory: {}", format_bytes(min_memory));
    println!("Memory range: {}", format_bytes(max_memory - min_memory));
    println!();

    // Calculate memory growth rate
    let growth_per_iteration = test_memory_growth as f64 / TEST_ITERATIONS as f64;
    println!(
        "Average growth per iteration: {:.2} bytes",
        growth_per_iteration
    );

    // Analyze trend
    if memory_samples.len() >= 2 {
        let first_half_avg = memory_samples[..memory_samples.len() / 2]
            .iter()
            .map(|(_, m)| *m)
            .sum::<isize>() as f64
            / (memory_samples.len() / 2) as f64;

        let second_half_avg = memory_samples[memory_samples.len() / 2..]
            .iter()
            .map(|(_, m)| *m)
            .sum::<isize>() as f64
            / (memory_samples.len() - memory_samples.len() / 2) as f64;

        let trend = second_half_avg - first_half_avg;

        println!("\nMEMORY TREND ANALYSIS:");
        println!("──────────────────────────────────────────");
        println!(
            "First half average: {}",
            format_bytes(first_half_avg as isize)
        );
        println!(
            "Second half average: {}",
            format_bytes(second_half_avg as isize)
        );
        println!("Trend: {}", format_bytes(trend as isize));

        // Verdict
        println!("\n🔍 VERDICT:");
        println!("──────────────────────────────────────────");

        let threshold_bytes = 1024 * 100; // 100 KB threshold
        if test_memory_growth.abs() < threshold_bytes {
            println!("✅ PASS: Memory usage is stable (growth < 100 KB)");
            println!("   No significant memory leak detected.");
        } else if growth_per_iteration < 10.0 {
            println!("⚠️  WARNING: Small memory growth detected");
            println!(
                "   Growth rate: {:.2} bytes/iteration",
                growth_per_iteration
            );
            println!("   This may be acceptable for your use case.");
        } else {
            println!("❌ FAIL: Potential memory leak detected!");
            println!(
                "   Growth rate: {:.2} bytes/iteration",
                growth_per_iteration
            );
            println!("   Total growth: {}", format_bytes(test_memory_growth));
            println!("   This indicates a possible memory leak that should be investigated.");
        }

        if trend.abs() as isize > threshold_bytes {
            println!("\n⚠️  Increasing memory trend detected between first and second half!");
        }
    }

    println!("\n========================================");
    println!("Analysis complete!");
    println!("========================================");

    Ok(())
}

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self>

Load workflow from JSON file

pub fn validate(&self) -> Result<()>

Validate the workflow structure

Trait Implementations

impl Clone for Workflow

fn clone(&self) -> Workflow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Workflow

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Workflow

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Workflow

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.