selen 0.15.5

Constraint Satisfaction Problem (CSP) solver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::collections::HashMap;

// Constraint Propagator Framework
// 
// This module provides a modular framework for organizing constraint propagators.
// It defines the core traits and management structures for the propagation system.
// 
// ## Framework Overview
// 
// The propagator framework provides:
// - `Prune`: Basic domain pruning interface
// - `Propagate`: Enhanced propagation with backtracking support  
// - `Propagators`: Container for managing multiple propagators
// - Modular patterns for constraint system organization
// 
// ## Implementation Note
// 
// This is currently a framework-only module to demonstrate the modular architecture
// design. In the final modularization phase, this would replace the monolithic
// propagator system in props/mod.rs (1,376 lines).

/// Unique identifier for propagators in the modular system.
pub type PropId = usize;

/// Core trait for constraint propagation in the modular framework.
pub trait Prune {
    // Framework method - would be implemented in final modularization
    // fn prune(&self, ctx: &mut Context) -> Option<()>;
}

/// Enhanced propagator trait with advanced propagation capabilities.
pub trait Propagate: Prune {
    // Framework methods - would be implemented in final modularization
    // fn propagate(&self, ctx: &mut Context, changed_vars: &[VarId]) -> Option<()>;
    // fn is_satisfied(&self, ctx: &Context) -> bool;
    // fn get_variables(&self) -> Vec<VarId>;
}

/// Container for managing multiple propagators efficiently.
/// 
/// This structure demonstrates how the modular system would organize
/// and manage constraint propagators in the final implementation.
pub struct Propagators {
    /// Map of propagator IDs to their implementations.
    /// In final implementation, would contain actual propagator instances.
    pub props: HashMap<PropId, usize>, // Placeholder - would be Box<dyn Propagate>
    
    /// Next available propagator ID.
    pub next_id: PropId,
}

impl Propagators {
    /// Create a new propagator container.
    pub fn new() -> Self {
        Self {
            props: HashMap::new(),
            next_id: 0,
        }
    }
    
    /// Framework method - would add actual propagator in final implementation.
    pub fn add_propagator_framework(&mut self) -> PropId {
        let id = self.next_id;
        self.props.insert(id, 0); // Placeholder
        self.next_id += 1;
        id
    }
    
    /// Framework method - would remove actual propagator in final implementation.
    pub fn remove_propagator_framework(&mut self, id: PropId) -> Option<usize> {
        self.props.remove(&id)
    }
    
    /// Get propagator count.
    pub fn len(&self) -> usize {
        self.props.len()
    }
    
    /// Check if container is empty.
    pub fn is_empty(&self) -> bool {
        self.props.is_empty()
    }
}