Struct InteractiveSession 

pub struct InteractiveSession<G>
where
    G: EvolutionaryGenome,
{
    pub version: u32,
    pub population: Vec<Candidate<G>>,
    pub generation: usize,
    pub evaluations_requested: usize,
    pub responses_received: usize,
    pub skipped: usize,
    pub aggregator: FitnessAggregator,
    pub request_history: Vec<SerializedRequest>,
    pub metadata: HashMap<String, String>,
    pub next_candidate_id: usize,
}

Complete state of an interactive evolution session

This struct captures all state needed to pause and resume an interactive evolution session, including population, fitness aggregator state, and session metadata.

Fields

version: u32

Schema version for forward compatibility

population: Vec<Candidate<G>>

Current population with fitness estimates

generation: usize

Current generation number

evaluations_requested: usize

Total evaluation requests made

responses_received: usize

Total responses received (excluding skips)

skipped: usize

Number of skipped evaluations

aggregator: FitnessAggregator

Fitness aggregator state

request_history: Vec<SerializedRequest>

History of evaluation requests (limited to recent history)

metadata: HashMap<String, String>

Custom session metadata

next_candidate_id: usize

Next candidate ID to assign

Implementations

impl<G> InteractiveSession<G>

where G: EvolutionaryGenome,

pub fn new(aggregator: FitnessAggregator) -> Self

Create a new empty session

pub fn with_population( population: Vec<Candidate<G>>, aggregator: FitnessAggregator, ) -> Self

Create a new session with initial population

pub fn next_id(&mut self) -> CandidateId

Get the next candidate ID and increment counter

pub fn add_candidate(&mut self, genome: G) -> CandidateId

Add a candidate to the population

pub fn get_candidate(&self, id: CandidateId) -> Option<&Candidate<G>>

Get a candidate by ID

pub fn get_candidate_mut( &mut self, id: CandidateId, ) -> Option<&mut Candidate<G>>

Get a mutable reference to a candidate by ID

pub fn unevaluated_candidates(&self) -> Vec<&Candidate<G>>

Get all candidates that haven’t been evaluated

pub fn ranked_candidates(&self) -> Vec<&Candidate<G>>

Get candidates sorted by fitness (best first)

pub fn best_candidate(&self) -> Option<&Candidate<G>>

Get the best candidate

pub fn coverage_stats(&self) -> CoverageStats

Calculate coverage statistics

pub fn record_request<GG: EvolutionaryGenome>( &mut self, request: &EvaluationRequest<GG>, )

Record that an evaluation request was made

pub fn record_response(&mut self, was_skipped: bool)

Record that a response was received

pub fn advance_generation(&mut self)

Advance to the next generation

pub fn update_fitness(&mut self, id: CandidateId, fitness: f64)

Update fitness estimate for a candidate

pub fn update_fitness_with_uncertainty( &mut self, id: CandidateId, estimate: FitnessEstimate, )

Update fitness with full uncertainty information

pub fn sync_fitness_estimates(&mut self)

Sync candidate fitness estimates from the aggregator

Updates all candidates with their current fitness estimates including uncertainty. Call this after processing responses to ensure candidates have up-to-date estimates.

pub fn all_fitness_estimates(&self) -> Vec<(CandidateId, FitnessEstimate)>

Get fitness estimates with uncertainty for all candidates

Returns a vector of (CandidateId, FitnessEstimate) pairs.

pub fn candidates_by_uncertainty(&self) -> Vec<&Candidate<G>>

Get candidates sorted by uncertainty (most uncertain first)

Useful for identifying which candidates need more evaluation.

pub fn average_uncertainty(&self) -> f64

Get the average uncertainty across all candidates

pub fn replace_population(&mut self, new_population: Vec<Candidate<G>>)

Replace the population with new candidates

pub fn set_metadata(&mut self, key: impl Into<String>, value: impl Into<String>)

Add metadata to the session

pub fn get_metadata(&self, key: &str) -> Option<&String>

Get metadata value

pub fn response_rate(&self) -> f64

Get response rate (responses / requests)

pub fn skip_rate(&self) -> f64

Get skip rate (skips / requests)

impl<G> InteractiveSession<G>

where G: EvolutionaryGenome + Serialize + for<'de> Deserialize<'de>,

File-based session persistence (requires checkpoint feature)

pub fn save(&self, path: &Path) -> Result<(), CheckpointError>

Save session to a file

pub fn load(path: &Path) -> Result<Self, CheckpointError>

Load session from a file

impl<G> InteractiveSession<G>

where G: EvolutionaryGenome + Serialize + for<'de> Deserialize<'de>,

pub fn to_json(&self) -> Result<String, CheckpointError>

Serialize session to JSON string (WASM-compatible)

pub fn from_json(json: &str) -> Result<Self, CheckpointError>

Deserialize session from JSON string (WASM-compatible)

Trait Implementations

impl<G> Clone for InteractiveSession<G>

where G: EvolutionaryGenome + Clone,

fn clone(&self) -> InteractiveSession<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G> Debug for InteractiveSession<G>

where G: EvolutionaryGenome + Debug,

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

Formats the value using the given formatter.

impl<'de, G> Deserialize<'de> for InteractiveSession<G>

where G: EvolutionaryGenome + Serialize + for<'a> Deserialize<'a>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G> Serialize for InteractiveSession<G>

where G: EvolutionaryGenome + Serialize + for<'a> Deserialize<'a>,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.