RsBundle  Diff

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

#[derive(Debug, Error)]
#[non_exhaustive]
pub enum SolverStateError<MErr, SErr> {
    #[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")]
    RestoreWeighterState,
    #[error("Getting the weighter state failed")]
    GetWeighterState,
}

impl<P, T, W, M> Saveable for Solver<P, T, W, M>
where
    P: FirstOrderProblem,
    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<
        <M::MasterProblem as MasterProblem<<P as FirstOrderProblem>::Minorant>>::Err,
        <M::MasterProblem as Saveable>::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)?;

        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)?;
            master
                .set_state(s.master_state)
                .map_err(SolverStateError::RestoreMasterState)?;

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

            cnt_null: self.cnt_null,
            cnt_evals: self.cnt_evals,
            weighter_state: self
                .weighter
                .get_state()
                .map_err(|_| SolverStateError::GetWeighterState)?,
            master_state: if let Some(m) = self.master_proc.as_ref() {
                Some(m.get_state().map_err(SolverStateError::GetMasterState)?)
            } else {
                None
            },
        })
    }
}