Struct abc::Hive [] [src]

pub struct Hive<Ctx: Context> {
    // some fields omitted
}

Runs the ABC algorithm, maintaining any necessary state.

Methods

impl<Ctx: Context> Hive<Ctx>

fn get(&self) -> AbcResult<MutexGuard<Candidate<Ctx::Solution>>>

Returns a guard for the current best solution found by the hive.

If the hive is running, you should drop the guard returned by this function as soon as convenient, since the logic of the hive can block on the availability of the associated mutex. If you plan on performing expensive computations, you should drop the guard as soon as possible, or acquire and clone it within a small block.

fn run_for_rounds(&self, rounds: usize) -> AbcResult<Candidate<Ctx::Solution>>

Runs for a fixed number of rounds, then return the best solution found.

If one of the worker threads panics while working, this will return Err(abc::Error). Otherwise, it will return Ok with a Candidate.

fn run_forever(&self) -> AbcResult<()>

Run indefinitely.

If one of the worker threads panics while working, this will return Err(abc::Error). Otherwise, it will return Ok(()).

fn stop(&self) -> AbcResult<()>

Stops a running hive.

If a worker thread has panicked, this returns Err(abc::Error).

fn set_sender(&mut self, sender: Sender<Candidate<Ctx::Solution>>)

Each new best candidate will be sent to sender.

This is kept in a separate function so that the hive can be borrowed while running.

fn get_round(&self) -> AbcResult<Option<usize>>

Returns the current round of a running hive.

If a worker thread has panicked and poisoned the task generator lock, get_round will return Err(abc::Error). If the hive has not been run, get_round will return Ok(None).

If the hive is running, this will return Ok(Some(n)). n will start at 0, and increment each time every task in the round has been claimed (though not necessarily completed) by a worker thread.

fn context(&self) -> &Ctx

Get a reference to the hive's context.

impl<Ctx: Context + 'static> Hive<Ctx>

fn stream(self) -> Receiver<Candidate<Ctx::Solution>>

Runs indefinitely in the background, providing a stream of results.

This method consumes the hive, which will run until the HiveBuilder object is dropped. It returns an mpsc::Receiver, which receives a Candidate each time the hive improves on its best solution.

Trait Implementations

impl<Ctx: Context> Debug for Hive<Ctx> where Ctx::Solution: Debug

fn fmt(&self, f: &mut Formatter) -> FmtResult

impl<Ctx: Context> Drop for Hive<Ctx>

fn drop(&mut self)