Struct Spinner 

pub struct Spinner {
    pub spinner: Spinners,
    /* private fields */
}

Main spinner struct

This holds all the information for the actual spinners

Fields

spinner: Spinners

The enum variant used in this spinner

Implementations

impl Spinner

pub fn new<T, S>(spinner: T, message: S) -> Self

where T: Into<Spinners> + Copy, S: Display,

Create a new spinner along with a message

Examples

Basic Usage:

use spinners_rs::{Spinners, Spinner};

let mut sp = Spinner::new(Spinners::Dots, "Doing some cool things...");
sp.start();

No Message:

use spinners_rs::{Spinners, Spinner};

let mut sp: Spinner = Spinners::Dots.into();
sp.start();

pub fn start(&mut self)

Start the spinner

Explained more in depth in the Spinner::new function.

pub fn stop(&mut self) -> Option<SendError<Event>>

Stops the spinner from running

Alternatively you can use the Spinner::stop_with_message or Spinner::stop_with_symbol function.

Example:

use spinners_rs::{Spinners, Spinner};
use std::{thread, time::Duration};

let mut sp: Spinner = Spinners::Dots.into();
sp.start();

thread::sleep(Duration::from_millis(1000));

sp.stop();

pub fn stop_with_message<S: Display>(&mut self, message: S)

Stops the spinner and replaces it with the given message

Example:

use spinners_rs::{Spinners, Spinner};
use std::{thread, time::Duration};

let mut sp: Spinner = Spinners::Dots.into();
sp.start();

thread::sleep(Duration::from_millis(1000));

sp.stop_with_message("We've finished that thing!");

pub fn stop_with_symbol<S: Display>(&mut self, symbol: S)

Stops the spinner and replaces the current frame with the given symbol

Example:

use spinners_rs::{Spinners, Spinner};
use std::{thread, time::Duration};

let mut sp: Spinner = Spinners::Dots.into();
sp.start();

thread::sleep(Duration::from_millis(1000));

sp.stop_with_symbol('✓');

pub fn set_interval(&mut self, interval: u64)

Updates the frame interval

This changes how fast each frame comes up

This can be changed before the spinner is started or after

Example:

use spinners_rs::{Spinners, Spinner};
use std::{thread, time::Duration};

let mut sp: Spinner = Spinners::Dots.into();
sp.start();

// Will run through one iteration of frames
thread::sleep(Duration::from_millis(1000));

sp.set_interval(500);

// Will now run through two iterations of the frames
thread::sleep(Duration::from_millis(1000));

sp.stop();

pub fn set_message<S: Display>(&mut self, message: S)

Sets the message to display

Similar to Spinner::set_interval, this can be set before or after a spinner is started

Example :

use spinners_rs::{Spinners, Spinner};
use std::{thread, time::Duration};

let mut sp: Spinner = Spinners::Dots.into();
sp.start();

thread::sleep(Duration::from_millis(1000));

sp.set_message("Doing some cool things...");

thread::sleep(Duration::from_millis(1000));

sp.stop();

pub fn set_spinner(&mut self, spinner: Spinners)

Changes the spinner mid run

This will change the spinner to the given one, allowing you to change the frames shown, on the current spinner without allocating a new variable and memory.

Example:

use std::{thread, time::Duration};

use spinners_rs::{Spinner, Spinners};

use strum::IntoEnumIterator;

let sps = Spinners::iter().collect::<Vec<Spinners>>();
let len = sps.len();
let sp = sps.get(0).unwrap();
let mut spinner: Spinner = (*sp).into();
spinner.start();

for (i, sp) in sps[1..].iter().enumerate() {
    spinner.set_spinner(*sp);

    thread::sleep(Duration::from_millis(1000));
}

pub fn get_name(&self) -> String

Gets the spinner name capitalizes the first letter.

Example:

use spinners_rs::{Spinners, Spinner};

let sp: Spinner = Spinners::Dots.into();
assert_eq!(sp.get_name(), "Dots");

Trait Implementations

impl Clone for Spinner

fn clone(&self) -> Spinner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Spinner

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

Formats the value using the given formatter.

impl Drop for Spinner

fn drop(&mut self)

Executes the destructor for this type.

impl From<Spinners> for Spinner

fn from(spinner: Spinners) -> Self

Converts to this type from the input type.