RsBundle  Diff

    cnt_evals: usize,
    weighter_state: W,
    master_state: Option<MasterProcessState<M>>,
}

#[derive(Debug, Error)]
#[non_exhaustive]
pub enum SolverStateError<MErr, SErr, WErr> {
pub enum SaveError<MErr, SErr, WErr> {
    #[error("Master problem creation failed")]
    BuildMaster(#[source] MErr),
    #[error("Restoring the master state failed")]
    RestoreMasterState(#[source] SErr),
    #[error("Getting the master state failed")]
    GetMasterState(#[source] SErr),
    #[error("Restoring the weighter state failed")]

    T: Terminator<SolverData> + Default,
    W: Weighter<SolverData> + Saveable + Default,
    M: MasterBuilder<P::Minorant>,
    M::MasterProblem: Saveable,
{
    type State = SyncSolverState<W::State, <M::MasterProblem as Saveable>::State>;

    type Err = SolverStateError<
    type Err = SaveError<
        <M::MasterProblem as MasterProblem<<P as FirstOrderProblem>::Minorant>>::Err,
        <M::MasterProblem as Saveable>::Err,
        W::Err,
    >;

    fn set_state(&mut self, state: Self::State) -> std::result::Result<(), Self::Err> {
        self.data = state.data;
        self.cnt_descent = state.cnt_descent;
        self.cnt_null = state.cnt_null;
        self.cnt_evals = state.cnt_evals;
        self.weighter
            .set_state(state.weighter_state)
            .map_err(SolverStateError::RestoreWeighterState)?;
            .map_err(SaveError::RestoreWeighterState)?;

        let (tx, rx) = channel();
        self.client_tx = Some(tx.clone());
        self.client_rx = Some(rx);

        self.master_proc = if let Some(s) = state.master_state {
            let mut master = self.master.build().map_err(SolverStateError::BuildMaster)?;
            let mut master = self.master.build().map_err(SaveError::BuildMaster)?;
            master
                .set_state(s.master_state)
                .map_err(SolverStateError::RestoreMasterState)?;
                .map_err(SaveError::RestoreMasterState)?;

            Some(MasterProcess::start_with_center_idx(
                master,
                tx,
                &mut self.threadpool,
                s.center_idx,
            ))

    /// Return the current solver state to the given writer.
    fn get_state(&self) -> std::result::Result<Self::State, Self::Err> {
        Ok(SyncSolverState {
            data: self.data.clone(),
            cnt_descent: self.cnt_descent,
            cnt_null: self.cnt_null,
            cnt_evals: self.cnt_evals,
            weighter_state: self.weighter.get_state().map_err(SolverStateError::GetWeighterState)?,
            weighter_state: self.weighter.get_state().map_err(SaveError::GetWeighterState)?,
            master_state: if let Some(m) = self.master_proc.as_ref() {
                Some(m.get_state().map_err(SolverStateError::GetMasterState)?)
                Some(m.get_state().map_err(SaveError::GetMasterState)?)
            } else {
                None
            },
        })
    }
}