Struct undo::timeline::Timeline

pub struct Timeline<A, F, const LIMIT: usize> { /* fields omitted */ }

A timeline of actions.

A timeline works mostly like a record but stores a fixed number of actions on the stack.

Can be used without the alloc feature.

Examples

let mut target = String::new();
let mut timeline = Timeline::<_, _, 32>::new();
timeline.apply(&mut target, Add('a'))?;
timeline.apply(&mut target, Add('b'))?;
timeline.apply(&mut target, Add('c'))?;
assert_eq!(target, "abc");
timeline.undo(&mut target).unwrap()?;
timeline.undo(&mut target).unwrap()?;
timeline.undo(&mut target).unwrap()?;
assert_eq!(target, "");
timeline.redo(&mut target).unwrap()?;
timeline.redo(&mut target).unwrap()?;
timeline.redo(&mut target).unwrap()?;
assert_eq!(target, "abc");

Implementations

impl<A, const LIMIT: usize> Timeline<A, fn(_: Signal), LIMIT>

pub fn new() -> Timeline<A, fn(_: Signal), LIMIT>

Returns a new timeline.

impl<A, F, const LIMIT: usize> Timeline<A, F, LIMIT>

pub fn len(&self) -> usize

Returns the number of actions in the timeline.

pub fn is_empty(&self) -> bool

Returns true if the timeline is empty.

pub const fn limit(&self) -> usize

Returns the limit of the record.

pub fn connect(&mut self, slot: F) -> Option<F>

Sets how the signal should be handled when the state changes.

The previous slot is returned if it exists.

pub fn disconnect(&mut self) -> Option<F>

Removes and returns the slot if it exists.

pub fn can_undo(&self) -> bool

Returns true if the timeline can undo.

pub fn can_redo(&self) -> bool

Returns true if the timeline can redo.

pub fn is_saved(&self) -> bool

Returns true if the target is in a saved state, false otherwise.

pub fn current(&self) -> usize

Returns the position of the current action.

pub fn display(&self) -> Display<'_, A, F, LIMIT>

Returns a structure for configurable formatting of the record.

impl<A: Action, F: FnMut(Signal), const LIMIT: usize> Timeline<A, F, LIMIT>

pub fn apply(&mut self, target: &mut A::Target, action: A) -> Result<A>

Pushes the action on top of the timeline and executes its apply method.

Errors

If an error occur when executing apply the error is returned.

pub fn undo(&mut self, target: &mut A::Target) -> Option<Result<A>>

Calls the undo method for the active action and sets the previous one as the new active one.

Errors

If an error occur when executing undo the error is returned.

pub fn redo(&mut self, target: &mut A::Target) -> Option<Result<A>>

Calls the redo method for the active action and sets the next one as the new active one.

Errors

If an error occur when applying redo the error is returned.

pub fn set_saved(&mut self, saved: bool)

Marks the target as currently being in a saved or unsaved state.

pub fn clear(&mut self)

Removes all actions from the timeline without undoing them.

impl<A: Action<Output = ()>, F: FnMut(Signal), const LIMIT: usize> Timeline<A, F, LIMIT>

pub fn revert(&mut self, target: &mut A::Target) -> Option<Result<A>>

Revert the changes done to the target since the saved state.

pub fn go_to(
    &mut self,
    target: &mut A::Target,
    current: usize
) -> Option<Result<A>>

Repeatedly calls undo or redo until the action at current is reached.

Errors

If an error occur when executing undo or redo the error is returned.

pub fn time_travel(
    &mut self,
    target: &mut A::Target,
    to: &DateTime<Utc>
) -> Option<Result<A>>

Go back or forward in the record to the action that was made closest to the datetime provided.

impl<A: ToString, F, const LIMIT: usize> Timeline<A, F, LIMIT>

pub fn undo_text(&self) -> Option<String>

Returns the string of the action which will be undone in the next call to undo.

pub fn redo_text(&self) -> Option<String>

Returns the string of the action which will be redone in the next call to redo.

Trait Implementations

impl<A: Clone, F: Clone, const LIMIT: usize> Clone for Timeline<A, F, LIMIT>

fn clone(&self) -> Timeline<A, F, LIMIT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, F, const LIMIT: usize> Debug for Timeline<A, F, LIMIT>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A, const LIMIT: usize> Default for Timeline<A, fn(_: Signal), LIMIT>

fn default() -> Timeline<A, fn(_: Signal), LIMIT>

Returns the “default value” for a type.

impl<'de, A, F, const LIMIT: usize> Deserialize<'de> for Timeline<A, F, LIMIT> where
    A: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, A, F, const LIMIT: usize> From<&'a Timeline<A, F, LIMIT>> for Display<'a, A, F, LIMIT>

fn from(timeline: &'a Timeline<A, F, LIMIT>) -> Self

Performs the conversion.

impl<A, F, const LIMIT: usize> Serialize for Timeline<A, F, LIMIT> where
    A: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.