Struct Graph 

pub struct Graph {
    pub def: GraphDef,
    pub context: Context,
}

Fields

def: GraphDef

context: Context

Implementations

impl Graph

pub fn new(def: GraphDef) -> Self

Examples found in repository

examples/parallel_execution.rs (line 308)

async fn analyze_and_execute(def: GraphDef) -> anyhow::Result<()> {
    // Create parallel executor
    let mut executor = ParallelExecutor::new(ParallelConfig {
        max_concurrent: 10,
        verbose: true,
    });

    // Register nodes
    for node_id in def.nodes.keys() {
        let node: Box<dyn Node> = Box::new(RuleNode::new(node_id, "true"));
        executor.register_node(node);
    }

    // Analyze parallelism
    let stats = executor.get_parallelism_stats(&def)?;
    stats.print_summary();

    // Execute the graph
    let mut graph = Graph::new(def);
    let start = Instant::now();
    executor.execute(&mut graph).await?;
    let duration = start.elapsed();

    println!("Execution completed in {:?}", duration);

    Ok(())
}

examples/simple_flow.rs (line 22)

async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    println!("=== Rust Logic Graph - Simple Flow Example ===\n");

    // Load graph definition from JSON
    let def = GraphIO::load_from_file("examples/simple_flow.json")?;
    println!("Loaded graph with {} nodes and {} edges\n",
        def.nodes.len(),
        def.edges.len()
    );

    // Create graph
    let mut graph = Graph::new(def);

    // Execute the graph
    println!("Starting graph execution...\n");
    Orchestrator::execute_graph(&mut graph).await?;

    // Display final context
    println!("\n=== Final Context ===");
    for (key, value) in &graph.context.data {
        println!("{}: {}", key, value);
    }

    println!("\n=== Execution Complete ===");
    Ok(())
}

examples/advanced_flow.rs (line 53)

async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();

    println!("=== Rust Logic Graph - Advanced Flow Example ===");
    println!("Scenario: User Analytics Report Generation with Permission Checks\n");

    // Load graph definition
    let def = GraphIO::load_from_file("examples/advanced_flow.json")?;

    // Create custom executor with specific node configurations
    let mut executor = Executor::new();

    // Register nodes with custom logic
    executor.register_node(Box::new(RuleNode::new(
        "validate_input",
        "user_id > 0"
    )));

    executor.register_node(Box::new(DBNode::new(
        "fetch_user_data",
        "SELECT * FROM users WHERE id = ?"
    )));

    executor.register_node(Box::new(RuleNode::new(
        "check_permissions",
        "user_role == \"admin\""
    )));

    executor.register_node(Box::new(DBNode::new(
        "query_analytics",
        "SELECT * FROM analytics WHERE user_id = ?"
    )));

    executor.register_node(Box::new(AINode::new(
        "generate_report",
        "Generate comprehensive analytics report from data"
    )));

    executor.register_node(Box::new(AINode::new(
        "send_notification",
        "Send notification to user about report status"
    )));

    // Create graph and set initial context
    let mut graph = Graph::new(def);

    // Simulate input data
    graph.context.data.insert("user_id".to_string(), json!(1001));
    graph.context.data.insert("user_role".to_string(), json!("admin"));

    println!("Initial Context:");
    println!("  - user_id: 1001");
    println!("  - user_role: admin\n");

    // Execute the graph
    println!("Starting advanced flow execution...\n");
    executor.execute(&mut graph).await?;

    // Display results
    println!("\n=== Execution Results ===");
    println!("\nContext Data:");
    for (key, value) in &graph.context.data {
        if key.ends_with("_result") {
            println!("  {}: {}", key, serde_json::to_string_pretty(&value)?);
        }
    }

    println!("\n=== Flow Complete ===");
    Ok(())
}

examples/grl_graph_flow.rs (line 58)

async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    println!("=== Rust Logic Graph - GRL Integration Example ===");
    println!("Scenario: Loan Application with Advanced GRL Rules\n");

    // Load graph definition
    let def = GraphIO::load_from_file("examples/grl_graph_flow.json")?;

    // Create custom executor with GRL-powered nodes
    let mut executor = Executor::new();

    // Input validation with GRL
    executor.register_node(Box::new(RuleNode::new(
        "input_validation",
        "loan_amount > 0 && loan_amount <= 1000000"
    )));

    // Fetch customer data
    executor.register_node(Box::new(DBNode::new(
        "fetch_customer",
        "SELECT * FROM customers WHERE id = ?"
    )));

    // Risk assessment with complex GRL rules
    executor.register_node(Box::new(RuleNode::new(
        "risk_assessment",
        "credit_score >= 600 && income >= loan_amount * 3"
    )));

    // Fraud detection AI
    executor.register_node(Box::new(AINode::new(
        "fraud_detection",
        "Analyze transaction patterns for fraud indicators"
    )));

    // Final approval decision
    executor.register_node(Box::new(RuleNode::new(
        "approval_decision",
        "risk_score < 50 && fraud_score < 30"
    )));

    // Notification
    executor.register_node(Box::new(AINode::new(
        "notification",
        "Generate approval/rejection notification email"
    )));

    // Create graph with initial context
    let mut graph = Graph::new(def);

    // Set application data
    graph.context.data.insert("loan_amount".to_string(), json!(50000));
    graph.context.data.insert("credit_score".to_string(), json!(720));
    graph.context.data.insert("income".to_string(), json!(180000));
    graph.context.data.insert("customer_id".to_string(), json!(12345));

    println!("Application Data:");
    println!("  Loan Amount: $50,000");
    println!("  Credit Score: 720");
    println!("  Annual Income: $180,000");
    println!("  Customer ID: 12345\n");

    // Execute the graph
    println!("Processing loan application through GRL-powered workflow...\n");
    executor.execute(&mut graph).await?;

    // Display results
    println!("\n=== Application Results ===\n");

    if let Some(validation) = graph.context.data.get("input_validation_result") {
        println!("✓ Input Validation: {}", validation);
    }

    if let Some(customer) = graph.context.data.get("fetch_customer_result") {
        println!("✓ Customer Data Retrieved");
    }

    if let Some(risk) = graph.context.data.get("risk_assessment_result") {
        println!("✓ Risk Assessment: {}", risk);
    }

    if let Some(fraud) = graph.context.data.get("fraud_detection_result") {
        println!("✓ Fraud Detection Completed");
    }

    if let Some(decision) = graph.context.data.get("approval_decision_result") {
        println!("✓ Approval Decision: {}", decision);
    }

    println!("\n=== GRL-Powered Workflow Complete ===");

    // Demonstrate standalone GRL engine
    println!("\n=== Bonus: Advanced GRL Rules ===\n");

    let mut grl_engine = RuleEngine::new();

    let advanced_rules = r#"
rule "HighValueLoan" salience 100 {
    when
        loan_amount > 100000 && credit_score < 750
    then
        requires_manual_review = true;
        approval_tier = "senior";
}

rule "StandardApproval" salience 50 {
    when
        loan_amount <= 100000 && credit_score >= 650
    then
        auto_approve = true;
        approval_tier = "standard";
}

rule "RiskMitigation" salience 25 {
    when
        debt_to_income_ratio > 0.4
    then
        requires_collateral = true;
        interest_rate_adjustment = 1.5;
}
"#;

    grl_engine.add_grl_rule(advanced_rules)?;

    println!("Advanced GRL rules loaded:");
    println!("  - High Value Loan Review");
    println!("  - Standard Approval Process");
    println!("  - Risk Mitigation Measures");

    println!("\n✅ All systems operational with rust-rule-engine integration!");

    Ok(())
}