Struct wfc::RunOwnAll

pub struct RunOwnAll<W: Wrap = WrapXY, F: ForbidPattern = ForbidNothing> { /* private fields */ }

Represents a running instance of wfc which allocates and owns its resources including a copy of the GlobalStats

Implementations

impl RunOwnAll

pub fn new<R: Rng>(
    output_size: Size,
    global_stats: GlobalStats,
    rng: &mut R
) -> Self

impl<W: Wrap> RunOwnAll<W>

pub fn new_wrap<R: Rng>(
    output_size: Size,
    global_stats: GlobalStats,
    wrap: W,
    rng: &mut R
) -> Self

impl<F> RunOwnAll<WrapXY, F>where
    F: Clone + Sync + Send + ForbidPattern,

pub fn new_forbid<R: Rng>(
    output_size: Size,
    global_stats: GlobalStats,
    forbid: F,
    rng: &mut R
) -> Self

impl<W: Wrap, F> RunOwnAll<W, F>where
    F: Clone + Sync + Send + ForbidPattern,

pub fn new_wrap_forbid<R: Rng>(
    output_size: Size,
    global_stats: GlobalStats,
    wrap: W,
    forbid: F,
    rng: &mut R
) -> Self

Examples found in repository

src/wfc.rs (line 1370)

    pub fn new<R: Rng>(
        output_size: Size,
        global_stats: GlobalStats,
        rng: &mut R,
    ) -> Self {
        Self::new_wrap_forbid(output_size, global_stats, WrapXY, ForbidNothing, rng)
    }
}

impl<W: Wrap> RunOwnAll<W> {
    pub fn new_wrap<R: Rng>(
        output_size: Size,
        global_stats: GlobalStats,
        wrap: W,
        rng: &mut R,
    ) -> Self {
        Self::new_wrap_forbid(output_size, global_stats, wrap, ForbidNothing, rng)
    }
}

impl<F: ForbidPattern> RunOwnAll<WrapXY, F>
where
    F: Clone + Sync + Send,
{
    pub fn new_forbid<R: Rng>(
        output_size: Size,
        global_stats: GlobalStats,
        forbid: F,
        rng: &mut R,
    ) -> Self {
        Self::new_wrap_forbid(output_size, global_stats, WrapXY, forbid, rng)
    }

impl<W: Wrap, F> RunOwnAll<W, F>where
    F: Clone + Sync + Send + ForbidPattern,

pub fn borrow_mut(&mut self) -> RunBorrow<'_, W, ForbidRef<'_, F>>

Examples found in repository

src/wfc.rs (line 1420)

    pub fn new_wrap_forbid<R: Rng>(
        output_size: Size,
        global_stats: GlobalStats,
        wrap: W,
        forbid: F,
        rng: &mut R,
    ) -> Self {
        let _ = wrap;
        let wave = Wave::new(output_size);
        let context = Context::new();
        let mut s = Self {
            context,
            wave,
            global_stats,
            output_wrap: PhantomData,
            forbid,
        };
        s.borrow_mut().reset(rng);
        s
    }
}

impl<W: Wrap, F: ForbidPattern> RunOwnAll<W, F>
where
    F: Clone + Sync + Send,
{
    pub fn borrow_mut(&mut self) -> RunBorrow<W, ForbidRef<F>> {
        let core = RunBorrowCore {
            context: &mut self.context,
            wave: &mut self.wave,
            global_stats: &self.global_stats,
            output_wrap: self.output_wrap,
        };
        RunBorrow {
            core,
            forbid: ForbidRef(&mut self.forbid),
        }
    }

    pub fn step<R: Rng>(&mut self, rng: &mut R) -> Result<Observe, PropagateError> {
        self.borrow_mut().step(rng)
    }

    pub fn collapse<R: Rng>(&mut self, rng: &mut R) -> Result<(), PropagateError> {
        self.borrow_mut().collapse(rng)
    }

pub fn step<R: Rng>(&mut self, rng: &mut R) -> Result<Observe, PropagateError>

pub fn collapse<R: Rng>(&mut self, rng: &mut R) -> Result<(), PropagateError>

Examples found in repository

src/retry.rs (line 135)

    fn retry<W, F, R>(&mut self, mut run: RunOwnAll<W, F>, rng: &mut R) -> Self::Return
    where
        W: Wrap + Clone + Sync + Send,
        F: ForbidPattern + Clone + Sync + Send,
        R: Rng,
    {
        loop {
            match run.collapse(rng) {
                Ok(()) => (),
                Err(PropagateError::Contradiction) => continue,
            }
            return run.into_wave();
        }
    }
}

impl RetryOwnAll for NumTimes {
    type Return = Result<Wave, PropagateError>;
    fn retry<W, F, R>(&mut self, mut run: RunOwnAll<W, F>, rng: &mut R) -> Self::Return
    where
        W: Wrap + Clone + Sync + Send,
        F: ForbidPattern + Clone + Sync + Send,
        R: Rng,
    {
        loop {
            match run.collapse(rng) {
                Ok(()) => return Ok(run.into_wave()),
                Err(e) => {
                    if self.0 == 0 {
                        return Err(e);
                    } else {
                        self.0 -= 1;
                    }
                }
            }
        }
    }

pub fn wave_cell_ref(&self, coord: Coord) -> WaveCellRef<'_>

pub fn wave_cell_ref_iter(&self) -> impl Iterator<Item = WaveCellRef<'_>>

pub fn wave_cell_ref_enumerate(
    &self
) -> impl Iterator<Item = (Coord, WaveCellRef<'_>)>

pub fn into_wave(self) -> Wave

Examples found in repository

src/retry.rs (line 139)

    fn retry<W, F, R>(&mut self, mut run: RunOwnAll<W, F>, rng: &mut R) -> Self::Return
    where
        W: Wrap + Clone + Sync + Send,
        F: ForbidPattern + Clone + Sync + Send,
        R: Rng,
    {
        loop {
            match run.collapse(rng) {
                Ok(()) => (),
                Err(PropagateError::Contradiction) => continue,
            }
            return run.into_wave();
        }
    }
}

impl RetryOwnAll for NumTimes {
    type Return = Result<Wave, PropagateError>;
    fn retry<W, F, R>(&mut self, mut run: RunOwnAll<W, F>, rng: &mut R) -> Self::Return
    where
        W: Wrap + Clone + Sync + Send,
        F: ForbidPattern + Clone + Sync + Send,
        R: Rng,
    {
        loop {
            match run.collapse(rng) {
                Ok(()) => return Ok(run.into_wave()),
                Err(e) => {
                    if self.0 == 0 {
                        return Err(e);
                    } else {
                        self.0 -= 1;
                    }
                }
            }
        }
    }

pub fn collapse_retrying<R, RO>(self, retry: RO, rng: &mut R) -> RO::Returnwhere
    R: Rng,
    RO: RetryOwnAll,

Trait Implementations

impl<W: Clone + Wrap, F: Clone + ForbidPattern> Clone for RunOwnAll<W, F>

fn clone(&self) -> RunOwnAll<W, F>

Returns a copy of the value.

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

Performs copy-assignment from source.