Struct SyncClient

pub struct SyncClient { /* private fields */ }

Implementations

impl SyncClient

pub fn new(address: &str) -> Result<SyncClient, Box<dyn Error>>

Connects to the Rocket Editor server and shakes hand with it

Examples found in repository

examples/basic_example.rs (line 21)

fn main() {
    env_logger::init().unwrap();
    info!("main: started");

    // Connect to the Rocket Editor (server process)
    let mut rocket: SyncClient = match SyncClient::new("localhost:1338") {
        Ok(x) => { info!("Connected to Rocket"); x },
        Err(_) => { println!("Couldn't connect to Rocket"); exit(2); },
    };

    let track_names = vec![
        "group0#track0".to_owned(),
        "group0#track1".to_owned(),
        "group0#track2".to_owned(),
        "group1#track0".to_owned(),
        "group1#track1".to_owned(),
        "group1#track2".to_owned(),
    ];

    rocket.send_track_names(&track_names).unwrap();

    let mut sync_device: SyncDevice = SyncDevice::new(125.0, 8);
    sync_device.is_paused = true;

    // add empty tracks
    for _ in track_names.iter() {
        sync_device.tracks.push(SyncTrack::new());
    }

    loop {
        // talk to Rocket
        match rocket.update(&mut sync_device) {
            Ok(_) => {},
            Err(err) => {
                // It's a Box<Error>, so we can't restore the original type.
                // Let's parse the debug string for now.
                let msg: &str = &format!("{:?}", err);
                if msg.contains("kind: UnexpectedEof") {
                    println!("Rocket disconnected. Exiting.");
                    exit(2);
                } else {
                    error!("{}", msg);
                }
            },
        }

        if !sync_device.is_paused {
            match rocket.send_row(&mut sync_device) {
                Ok(_) => {},
                Err(e) => warn!("{:?}", e),
            }
        }

        // calculate track values and print
        println!("Row: {}, Time: {}", sync_device.row, sync_device.time);

        for (idx, track) in sync_device.tracks.iter().enumerate() {
            println!("Track {} : {:>10.5}", track_names[idx], track.value_at(sync_device.row));
        }

        // update time
        if !sync_device.is_paused {
            sync_device.time += 16;// 1s / 60 frames
            sync_device.set_row_from_time();
        }

        // sleep a bit
        sleep(Duration::from_millis(16));

    }

}

pub fn update( &mut self, device: &mut SyncDevice, ) -> Result<bool, Box<dyn Error>>

Read from the stream and process commands until the server runs out of things to send.

Returns an Ok(true) if there should be a redraw.

Examples found in repository

examples/basic_example.rs (line 47)

fn main() {
    env_logger::init().unwrap();
    info!("main: started");

    // Connect to the Rocket Editor (server process)
    let mut rocket: SyncClient = match SyncClient::new("localhost:1338") {
        Ok(x) => { info!("Connected to Rocket"); x },
        Err(_) => { println!("Couldn't connect to Rocket"); exit(2); },
    };

    let track_names = vec![
        "group0#track0".to_owned(),
        "group0#track1".to_owned(),
        "group0#track2".to_owned(),
        "group1#track0".to_owned(),
        "group1#track1".to_owned(),
        "group1#track2".to_owned(),
    ];

    rocket.send_track_names(&track_names).unwrap();

    let mut sync_device: SyncDevice = SyncDevice::new(125.0, 8);
    sync_device.is_paused = true;

    // add empty tracks
    for _ in track_names.iter() {
        sync_device.tracks.push(SyncTrack::new());
    }

    loop {
        // talk to Rocket
        match rocket.update(&mut sync_device) {
            Ok(_) => {},
            Err(err) => {
                // It's a Box<Error>, so we can't restore the original type.
                // Let's parse the debug string for now.
                let msg: &str = &format!("{:?}", err);
                if msg.contains("kind: UnexpectedEof") {
                    println!("Rocket disconnected. Exiting.");
                    exit(2);
                } else {
                    error!("{}", msg);
                }
            },
        }

        if !sync_device.is_paused {
            match rocket.send_row(&mut sync_device) {
                Ok(_) => {},
                Err(e) => warn!("{:?}", e),
            }
        }

        // calculate track values and print
        println!("Row: {}, Time: {}", sync_device.row, sync_device.time);

        for (idx, track) in sync_device.tracks.iter().enumerate() {
            println!("Track {} : {:>10.5}", track_names[idx], track.value_at(sync_device.row));
        }

        // update time
        if !sync_device.is_paused {
            sync_device.time += 16;// 1s / 60 frames
            sync_device.set_row_from_time();
        }

        // sleep a bit
        sleep(Duration::from_millis(16));

    }

}

pub fn send_row(&mut self, device: &SyncDevice) -> Result<(), Box<dyn Error>>

Examples found in repository

examples/basic_example.rs (line 63)

fn main() {
    env_logger::init().unwrap();
    info!("main: started");

    // Connect to the Rocket Editor (server process)
    let mut rocket: SyncClient = match SyncClient::new("localhost:1338") {
        Ok(x) => { info!("Connected to Rocket"); x },
        Err(_) => { println!("Couldn't connect to Rocket"); exit(2); },
    };

    let track_names = vec![
        "group0#track0".to_owned(),
        "group0#track1".to_owned(),
        "group0#track2".to_owned(),
        "group1#track0".to_owned(),
        "group1#track1".to_owned(),
        "group1#track2".to_owned(),
    ];

    rocket.send_track_names(&track_names).unwrap();

    let mut sync_device: SyncDevice = SyncDevice::new(125.0, 8);
    sync_device.is_paused = true;

    // add empty tracks
    for _ in track_names.iter() {
        sync_device.tracks.push(SyncTrack::new());
    }

    loop {
        // talk to Rocket
        match rocket.update(&mut sync_device) {
            Ok(_) => {},
            Err(err) => {
                // It's a Box<Error>, so we can't restore the original type.
                // Let's parse the debug string for now.
                let msg: &str = &format!("{:?}", err);
                if msg.contains("kind: UnexpectedEof") {
                    println!("Rocket disconnected. Exiting.");
                    exit(2);
                } else {
                    error!("{}", msg);
                }
            },
        }

        if !sync_device.is_paused {
            match rocket.send_row(&mut sync_device) {
                Ok(_) => {},
                Err(e) => warn!("{:?}", e),
            }
        }

        // calculate track values and print
        println!("Row: {}, Time: {}", sync_device.row, sync_device.time);

        for (idx, track) in sync_device.tracks.iter().enumerate() {
            println!("Track {} : {:>10.5}", track_names[idx], track.value_at(sync_device.row));
        }

        // update time
        if !sync_device.is_paused {
            sync_device.time += 16;// 1s / 60 frames
            sync_device.set_row_from_time();
        }

        // sleep a bit
        sleep(Duration::from_millis(16));

    }

}

pub fn send_track_names( &mut self, track_names: &Vec<String>, ) -> Result<(), Box<dyn Error>>

Send track names to Rocket, including group prefix

Examples found in repository

examples/basic_example.rs (line 35)

fn main() {
    env_logger::init().unwrap();
    info!("main: started");

    // Connect to the Rocket Editor (server process)
    let mut rocket: SyncClient = match SyncClient::new("localhost:1338") {
        Ok(x) => { info!("Connected to Rocket"); x },
        Err(_) => { println!("Couldn't connect to Rocket"); exit(2); },
    };

    let track_names = vec![
        "group0#track0".to_owned(),
        "group0#track1".to_owned(),
        "group0#track2".to_owned(),
        "group1#track0".to_owned(),
        "group1#track1".to_owned(),
        "group1#track2".to_owned(),
    ];

    rocket.send_track_names(&track_names).unwrap();

    let mut sync_device: SyncDevice = SyncDevice::new(125.0, 8);
    sync_device.is_paused = true;

    // add empty tracks
    for _ in track_names.iter() {
        sync_device.tracks.push(SyncTrack::new());
    }

    loop {
        // talk to Rocket
        match rocket.update(&mut sync_device) {
            Ok(_) => {},
            Err(err) => {
                // It's a Box<Error>, so we can't restore the original type.
                // Let's parse the debug string for now.
                let msg: &str = &format!("{:?}", err);
                if msg.contains("kind: UnexpectedEof") {
                    println!("Rocket disconnected. Exiting.");
                    exit(2);
                } else {
                    error!("{}", msg);
                }
            },
        }

        if !sync_device.is_paused {
            match rocket.send_row(&mut sync_device) {
                Ok(_) => {},
                Err(e) => warn!("{:?}", e),
            }
        }

        // calculate track values and print
        println!("Row: {}, Time: {}", sync_device.row, sync_device.time);

        for (idx, track) in sync_device.tracks.iter().enumerate() {
            println!("Track {} : {:>10.5}", track_names[idx], track.value_at(sync_device.row));
        }

        // update time
        if !sync_device.is_paused {
            sync_device.time += 16;// 1s / 60 frames
            sync_device.set_row_from_time();
        }

        // sleep a bit
        sleep(Duration::from_millis(16));

    }

}

pub fn handle_set_key_cmd( &mut self, device: &mut SyncDevice, ) -> Result<(), Box<dyn Error>>

Adds a key frame to a track

pub fn handle_del_key_cmd( &mut self, device: &mut SyncDevice, ) -> Result<(), Box<dyn Error>>

Deletes a key from a track

pub fn handle_set_row_cmd( &mut self, device: &mut SyncDevice, ) -> Result<(), Box<dyn Error>>

Sets the current row from server. Sets the current time based on the row and rps.

pub fn handle_pause_cmd( &mut self, device: &mut SyncDevice, ) -> Result<(), Box<dyn Error>>