RsBundle  Diff

        self.pool = Some(pool);
    }

    fn stop(&mut self) {
        self.pool.take();
    }

    fn evaluate<S>(&mut self, i: usize, y: Arc<DVector>, tx: S) -> Result<()>
    fn evaluate(&mut self, i: usize, y: Arc<DVector>, tx: impl ResultSender<Self> + 'static) -> Result<()> {
    where
        S: ResultSender<Self> + 'static,
    {
        if self.pool.is_none() {
            self.start()
        }
        let sub = self.subs[i].clone();
        let subdatas = self.subdatas.clone();
        // Attention: `y` might be shorter than the set of active constraints
        // because evaluation and problem update are not synchronized, i.e. the

                }
                Err(err) => tx.error(err).unwrap(),
            }
        });
        Ok(())
    }

    fn update<U, S>(&mut self, state: U, tx: S) -> Result<()>
    where
        U: ParallelUpdateState<<Self::Minorant as Minorant>::Primal>,
        S: UpdateSender<Self> + 'static,
    fn update(
        &mut self,
        state: impl ParallelUpdateState<<Self::Minorant as Minorant>::Primal>,
        tx: impl UpdateSender<Self> + 'static,
    {
    ) -> Result<()> {
        if self.inactive_constraints.read().unwrap().is_empty() {
            return Ok(());
        }

        let inactive_constraints = self.inactive_constraints.clone();
        let active_constraints = self.active_constraints.clone();
        let subdatas = self.subdatas.clone();