Struct RocketClient

pub struct RocketClient { /* private fields */ }

The RocketClient type. This contains the connected socket and other fields.

Implementations

impl RocketClient

pub fn new() -> Result<Self, Error>

Construct a new RocketClient.

This constructs a new Rocket client and connects to localhost on port 1338.

Errors

Error::Connect if connection cannot be established, or Error::Handshake if the handshake fails.

Examples

let mut rocket = RocketClient::new()?;

Examples found in repository

examples/edit.rs (line 9)

fn main() -> Result<(), Box<dyn Error>> {
    let mut rocket = RocketClient::new()?;
    rocket.get_track_mut("test")?;
    rocket.get_track_mut("test2")?;
    rocket.get_track_mut("a:test2")?;

    let mut current_row = 0;
    let mut paused = true;

    loop {
        if let Some(event) = rocket.poll_events()? {
            match event {
                Event::SetRow(row) => {
                    println!("SetRow (row: {:?})", row);
                    current_row = row;
                }
                Event::Pause(state) => {
                    paused = state;

                    let track1 = rocket.get_track("test").unwrap();
                    println!(
                        "Pause (value: {:?}) (row: {:?})",
                        track1.get_value(current_row as f32),
                        current_row
                    );
                }
                Event::SaveTracks => {
                    // Obtain a clone of current track state
                    let tracks = rocket.save_tracks();

                    // Open a file for writing, create if not present,
                    // truncate (overwrite) in case it has previous contents.
                    let mut file = OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(TRACKS_FILE)?;

                    // Serialize tracks into the file using bincode
                    let bincode_conf = bincode::config::standard();
                    bincode::encode_into_std_write(tracks, &mut file, bincode_conf)?;
                    // See examples/play.rs for deserializing and playback
                    println!("Tracks saved to {}", TRACKS_FILE);
                }
            }
            println!("{:?}", event);
        }

        if !paused {
            current_row += 1;
            rocket.set_row(current_row)?;
        }

        std::thread::sleep(Duration::from_millis(32));
    }
}

pub fn connect(addr: impl ToSocketAddrs) -> Result<Self, Error>

Construct a new RocketClient.

This constructs a new Rocket client and connects to a specified host and port.

Errors

Error::Connect if connection cannot be established, or Error::Handshake if the handshake fails.

Examples

let mut rocket = RocketClient::connect(("localhost", 1338))?;

pub fn get_track_mut(&mut self, name: &str) -> Result<&mut Track, Error>

Get track by name.

If the track does not yet exist it will be created.

Errors

This method can return an Error::IOError if Rocket tracker disconnects.

Panics

Will panic if name’s length exceeds u32::MAX.

Examples

let track = rocket.get_track_mut("namespace:track")?;
track.get_value(3.5);

Examples found in repository

examples/edit.rs (line 10)

fn main() -> Result<(), Box<dyn Error>> {
    let mut rocket = RocketClient::new()?;
    rocket.get_track_mut("test")?;
    rocket.get_track_mut("test2")?;
    rocket.get_track_mut("a:test2")?;

    let mut current_row = 0;
    let mut paused = true;

    loop {
        if let Some(event) = rocket.poll_events()? {
            match event {
                Event::SetRow(row) => {
                    println!("SetRow (row: {:?})", row);
                    current_row = row;
                }
                Event::Pause(state) => {
                    paused = state;

                    let track1 = rocket.get_track("test").unwrap();
                    println!(
                        "Pause (value: {:?}) (row: {:?})",
                        track1.get_value(current_row as f32),
                        current_row
                    );
                }
                Event::SaveTracks => {
                    // Obtain a clone of current track state
                    let tracks = rocket.save_tracks();

                    // Open a file for writing, create if not present,
                    // truncate (overwrite) in case it has previous contents.
                    let mut file = OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(TRACKS_FILE)?;

                    // Serialize tracks into the file using bincode
                    let bincode_conf = bincode::config::standard();
                    bincode::encode_into_std_write(tracks, &mut file, bincode_conf)?;
                    // See examples/play.rs for deserializing and playback
                    println!("Tracks saved to {}", TRACKS_FILE);
                }
            }
            println!("{:?}", event);
        }

        if !paused {
            current_row += 1;
            rocket.set_row(current_row)?;
        }

        std::thread::sleep(Duration::from_millis(32));
    }
}

pub fn get_track(&self, name: &str) -> Option<&Track>

Get track by name.

You should use get_track_mut to create a track.

Examples found in repository

examples/edit.rs (line 27)

fn main() -> Result<(), Box<dyn Error>> {
    let mut rocket = RocketClient::new()?;
    rocket.get_track_mut("test")?;
    rocket.get_track_mut("test2")?;
    rocket.get_track_mut("a:test2")?;

    let mut current_row = 0;
    let mut paused = true;

    loop {
        if let Some(event) = rocket.poll_events()? {
            match event {
                Event::SetRow(row) => {
                    println!("SetRow (row: {:?})", row);
                    current_row = row;
                }
                Event::Pause(state) => {
                    paused = state;

                    let track1 = rocket.get_track("test").unwrap();
                    println!(
                        "Pause (value: {:?}) (row: {:?})",
                        track1.get_value(current_row as f32),
                        current_row
                    );
                }
                Event::SaveTracks => {
                    // Obtain a clone of current track state
                    let tracks = rocket.save_tracks();

                    // Open a file for writing, create if not present,
                    // truncate (overwrite) in case it has previous contents.
                    let mut file = OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(TRACKS_FILE)?;

                    // Serialize tracks into the file using bincode
                    let bincode_conf = bincode::config::standard();
                    bincode::encode_into_std_write(tracks, &mut file, bincode_conf)?;
                    // See examples/play.rs for deserializing and playback
                    println!("Tracks saved to {}", TRACKS_FILE);
                }
            }
            println!("{:?}", event);
        }

        if !paused {
            current_row += 1;
            rocket.set_row(current_row)?;
        }

        std::thread::sleep(Duration::from_millis(32));
    }
}

pub fn save_tracks(&self) -> &Tracks

Get a snapshot of the tracks in the session.

The returned Tracks can be dumped to a file in any supported format. The counterpart to this function is RocketPlayer::new, which loads tracks for playback.

Example

let mut rocket = RocketClient::new()?;

// Create tracks, call poll_events, etc...

// Open a file for writing
let mut file = OpenOptions::new()
    .write(true)
    .create(true)
    .truncate(true)
    .open("tracks.bin")
    .expect("Failed to open tracks.bin for writing");

// Save a snapshot of the client to a file for playback in release builds
let tracks = rocket.save_tracks();
bincode::encode_into_std_write(tracks, &mut file, bincode::config::standard())
    .expect("Failed to encode tracks.bin");

Examples found in repository

examples/edit.rs (line 36)

fn main() -> Result<(), Box<dyn Error>> {
    let mut rocket = RocketClient::new()?;
    rocket.get_track_mut("test")?;
    rocket.get_track_mut("test2")?;
    rocket.get_track_mut("a:test2")?;

    let mut current_row = 0;
    let mut paused = true;

    loop {
        if let Some(event) = rocket.poll_events()? {
            match event {
                Event::SetRow(row) => {
                    println!("SetRow (row: {:?})", row);
                    current_row = row;
                }
                Event::Pause(state) => {
                    paused = state;

                    let track1 = rocket.get_track("test").unwrap();
                    println!(
                        "Pause (value: {:?}) (row: {:?})",
                        track1.get_value(current_row as f32),
                        current_row
                    );
                }
                Event::SaveTracks => {
                    // Obtain a clone of current track state
                    let tracks = rocket.save_tracks();

                    // Open a file for writing, create if not present,
                    // truncate (overwrite) in case it has previous contents.
                    let mut file = OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(TRACKS_FILE)?;

                    // Serialize tracks into the file using bincode
                    let bincode_conf = bincode::config::standard();
                    bincode::encode_into_std_write(tracks, &mut file, bincode_conf)?;
                    // See examples/play.rs for deserializing and playback
                    println!("Tracks saved to {}", TRACKS_FILE);
                }
            }
            println!("{:?}", event);
        }

        if !paused {
            current_row += 1;
            rocket.set_row(current_row)?;
        }

        std::thread::sleep(Duration::from_millis(32));
    }
}

pub fn set_row(&mut self, row: u32) -> Result<(), Error>

Send a SetRow message.

This changes the current row on the tracker side.

Errors

This method can return an Error::IOError if Rocket tracker disconnects.

Examples found in repository

examples/edit.rs (line 58)

fn main() -> Result<(), Box<dyn Error>> {
    let mut rocket = RocketClient::new()?;
    rocket.get_track_mut("test")?;
    rocket.get_track_mut("test2")?;
    rocket.get_track_mut("a:test2")?;

    let mut current_row = 0;
    let mut paused = true;

    loop {
        if let Some(event) = rocket.poll_events()? {
            match event {
                Event::SetRow(row) => {
                    println!("SetRow (row: {:?})", row);
                    current_row = row;
                }
                Event::Pause(state) => {
                    paused = state;

                    let track1 = rocket.get_track("test").unwrap();
                    println!(
                        "Pause (value: {:?}) (row: {:?})",
                        track1.get_value(current_row as f32),
                        current_row
                    );
                }
                Event::SaveTracks => {
                    // Obtain a clone of current track state
                    let tracks = rocket.save_tracks();

                    // Open a file for writing, create if not present,
                    // truncate (overwrite) in case it has previous contents.
                    let mut file = OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(TRACKS_FILE)?;

                    // Serialize tracks into the file using bincode
                    let bincode_conf = bincode::config::standard();
                    bincode::encode_into_std_write(tracks, &mut file, bincode_conf)?;
                    // See examples/play.rs for deserializing and playback
                    println!("Tracks saved to {}", TRACKS_FILE);
                }
            }
            println!("{:?}", event);
        }

        if !paused {
            current_row += 1;
            rocket.set_row(current_row)?;
        }

        std::thread::sleep(Duration::from_millis(32));
    }
}

pub fn poll_events(&mut self) -> Result<Option<Event>, Error>

Poll for new events from the tracker.

This polls from events from the tracker. You should call this fairly often your main loop. It is recommended to keep calling this as long as your receive Some(Event).

Errors

This method can return an Error::IOError if the rocket tracker disconnects.

Examples

while let Some(event) = rocket.poll_events()? {
    match event {
        // Do something with the various events.
        _ => (),
    }
}

Examples found in repository

examples/edit.rs (line 18)

fn main() -> Result<(), Box<dyn Error>> {
    let mut rocket = RocketClient::new()?;
    rocket.get_track_mut("test")?;
    rocket.get_track_mut("test2")?;
    rocket.get_track_mut("a:test2")?;

    let mut current_row = 0;
    let mut paused = true;

    loop {
        if let Some(event) = rocket.poll_events()? {
            match event {
                Event::SetRow(row) => {
                    println!("SetRow (row: {:?})", row);
                    current_row = row;
                }
                Event::Pause(state) => {
                    paused = state;

                    let track1 = rocket.get_track("test").unwrap();
                    println!(
                        "Pause (value: {:?}) (row: {:?})",
                        track1.get_value(current_row as f32),
                        current_row
                    );
                }
                Event::SaveTracks => {
                    // Obtain a clone of current track state
                    let tracks = rocket.save_tracks();

                    // Open a file for writing, create if not present,
                    // truncate (overwrite) in case it has previous contents.
                    let mut file = OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(TRACKS_FILE)?;

                    // Serialize tracks into the file using bincode
                    let bincode_conf = bincode::config::standard();
                    bincode::encode_into_std_write(tracks, &mut file, bincode_conf)?;
                    // See examples/play.rs for deserializing and playback
                    println!("Tracks saved to {}", TRACKS_FILE);
                }
            }
            println!("{:?}", event);
        }

        if !paused {
            current_row += 1;
            rocket.set_row(current_row)?;
        }

        std::thread::sleep(Duration::from_millis(32));
    }
}

Trait Implementations

impl Debug for RocketClient

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

Formats the value using the given formatter.