Trait OctatrackFileIO 

pub trait OctatrackFileIO: Serialize + for<'a> Deserialize<'a> {
    // Provided methods
    fn repr(&self, newlines: Option<bool>)
       where Self: Debug { ... }
    fn from_data_file(path: &Path) -> Result<Self, OtToolsIoError> { ... }
    fn from_bytes(bytes: &[u8]) -> Result<Self, OtToolsIoError> { ... }
    fn to_data_file(&self, path: &Path) -> Result<(), OtToolsIoError> { ... }
    fn to_bytes(&self) -> Result<Vec<u8>, OtToolsIoError> { ... }
    fn from_yaml_file(path: &Path) -> Result<Self, OtToolsIoError> { ... }
    fn from_yaml_str(yaml: &str) -> Result<Self, OtToolsIoError> { ... }
    fn to_yaml_file(&self, path: &Path) -> Result<(), OtToolsIoError> { ... }
    fn to_yaml_string(&self) -> Result<String, OtToolsIoError> { ... }
    fn from_json_file(path: &Path) -> Result<Self, OtToolsIoError> { ... }
    fn from_json_str(json: &str) -> Result<Self, OtToolsIoError> { ... }
    fn to_json_file(&self, path: &Path) -> Result<(), OtToolsIoError> { ... }
    fn to_json_string(&self) -> Result<String, OtToolsIoError> { ... }
    fn encode(&self) -> Result<Vec<u8>, OtToolsIoError>
       where Self: Serialize { ... }
    fn decode(bytes: &[u8]) -> Result<Self, OtToolsIoError>
       where Self: Sized + for<'a> Deserialize<'a> { ... }
}

Convenience trait for types which directly correspond to Elektron Octatrack binary data files. Associated functions and methods etc. for File I/O, plus a repr method for debugging.

Provided Methods

fn repr(&self, newlines: Option<bool>)

where Self: Debug,

Read type from an Octatrack data file at path

use ot_tools_io::{BankFile, OctatrackFileIO};
// no newlines
BankFile::from_data_file(&path).unwrap().repr(None);
// no newlines
BankFile::from_data_file(&path).unwrap().repr(Some(false));
// with newlines
BankFile::from_data_file(&path).unwrap().repr(Some(true));

Examples found in repository

examples/show_sample_settings_file.rs (line 15)

fn main() -> Result<(), OtToolsIoError> {
    let dirpath = PathBuf::from("ot-tools-io")
        .join("test-data")
        .join("samples");
    let f = SampleSettingsFile::from_data_file(&dirpath.join("sample.ot"))?;
    f.repr(Some(true));

    Ok(())
}

examples/project_bin_repr.rs (line 13)

fn main() -> Result<(), OtToolsIoError> {
    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
    let project_fpath = blank_project_dirpath.join("project.work");
    ProjectFile::from_data_file(&project_fpath)?.repr(None);
    Ok(())
}

fn from_data_file(path: &Path) -> Result<Self, OtToolsIoError>

Read type from an Octatrack data file at path

use ot_tools_io::{BankFile, OctatrackFileIO};
let bank = BankFile::from_data_file(&path).unwrap();
assert_eq!(bank.datatype_version, 23);

Examples found in repository

examples/show_sample_settings_file.rs (line 14)

fn main() -> Result<(), OtToolsIoError> {
    let dirpath = PathBuf::from("ot-tools-io")
        .join("test-data")
        .join("samples");
    let f = SampleSettingsFile::from_data_file(&dirpath.join("sample.ot"))?;
    f.repr(Some(true));

    Ok(())
}

examples/project_bin_repr.rs (line 13)

fn main() -> Result<(), OtToolsIoError> {
    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
    let project_fpath = blank_project_dirpath.join("project.work");
    ProjectFile::from_data_file(&project_fpath)?.repr(None);
    Ok(())
}

examples/project_bin_to_json.rs (line 14)

fn main() -> Result<(), OtToolsIoError> {
    let path = PathBuf::from("test-data")
        .join("blank-project")
        .join("project.work");
    let outpath = PathBuf::from("project.json");
    ProjectFile::from_data_file(&path)?.to_json_file(&outpath)?;
    println!("New json file written to {outpath:?}");
    Ok(())
}

examples/project_bin_to_yaml.rs (line 13)

fn main() -> Result<(), OtToolsIoError> {
    let path = PathBuf::from("test-data")
        .join("blank-project")
        .join("project.work");
    let outpath = PathBuf::from("project.yaml");
    ProjectFile::from_data_file(&path)?.to_yaml_file(&outpath)?;
    println!("New yaml file written to {outpath:?}");
    Ok(())
}

examples/check_checksums.rs (line 16)

fn arrangement_check() -> Result<(), OtToolsIoError> {
    let fp = PathBuf::from("test-data")
        .join("arrange")
        .join("full-options.work");
    let bin = ArrangementFile::from_data_file(&fp)?;
    println!("checksum from arrangement file: {:?}", bin.checksum);

    let checksum = bin.calculate_checksum()?;
    println!("calculated checksum for arrangement file: {checksum:?}");

    if bin.check_checksum()? {
        println!("arrangement file checksum is ok");
    } else {
        println!("bad arrangement file checksum");
        panic!()
    };
    Ok(())
}

fn bank_check() -> Result<(), OtToolsIoError> {
    let fp = PathBuf::from("test-data")
        .join("blank-project")
        .join("bank01.work");
    let bin = BankFile::from_data_file(&fp)?;
    println!("checksum from bank file: {:?}", bin.checksum);

    let checksum = bin.calculate_checksum()?;
    println!("calculated checksum for bank file: {checksum:?}");

    if bin.check_checksum()? {
        println!("bank file checksum is ok");
    } else {
        println!("bad bank file checksum");
        panic!()
    };
    Ok(())
}

fn markers_check() -> Result<(), OtToolsIoError> {
    let fp = PathBuf::from("test-data")
        .join("blank-project")
        .join("markers.work");
    let bin = ArrangementFile::from_data_file(&fp)?;
    println!("checksum from markers file: {:?}", bin.checksum);

    let checksum = bin.calculate_checksum()?;
    println!("calculated checksum for markers file: {checksum:?}");

    if bin.check_checksum()? {
        println!("markers file checksum is ok");
    } else {
        println!("bad markers file checksum");
        panic!()
    };

    Ok(())
}

fn sample_check() -> Result<(), OtToolsIoError> {
    let fp = PathBuf::from("test-data").join("samples").join("sample.ot");
    let bin = SampleSettingsFile::from_data_file(&fp)?;
    println!("checksum from sample settings file: {:?}", bin.checksum);

    let checksum = bin.calculate_checksum()?;
    println!("calculated checksum for sample settings file: {checksum:?}");

    if bin.check_checksum()? {
        println!("sample settings file checksum is ok");
    } else {
        println!("bad sample settings file checksum");
        panic!()
    };
    Ok(())
}

examples/list_sample_slots.rs (line 12)

fn main() -> Result<(), OtToolsIoError> {
    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
    let project_fpath = blank_project_dirpath.join("project.work");
    let project = ProjectFile::from_data_file(&project_fpath)?;

    println!("====================================");
    println!("|       Project Sample Slots       |");
    println!("====================================");
    println!("-------------- Static --------------");
    for (idx, sample_slot) in project.slots.static_slots.iter().enumerate() {
        println!("Static Slot {}: {sample_slot:?}", idx + 1)
    }
    println!("--------------- Flex ---------------");
    for (idx, sample_slot) in project.slots.flex_slots.iter().enumerate() {
        println!("Flex Slot {}: {sample_slot:?}", idx + 1)
    }
    Ok(())
}

Additional examples can be found in:

• examples/read_project_files.rs

fn from_bytes(bytes: &[u8]) -> Result<Self, OtToolsIoError>

Read type from bytes

// need to create everything from scratch in this example as many bytes otherwise
use serde::{Deserialize, Serialize};
use ot_tools_io::{OctatrackFileIO, OtToolsIoError};

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Something {
    value: u8,
}

impl OctatrackFileIO for Something {}

let x = [10];

let r = Something::from_bytes(&x);
assert!(r.is_ok());
assert_eq!(r.unwrap(), Something { value: 10});

fn to_data_file(&self, path: &Path) -> Result<(), OtToolsIoError>

Write type to an Octatrack data file at path

use ot_tools_io::{OctatrackFileIO, BankFile};
let r = BankFile::default().to_data_file(&path);
assert!(r.is_ok());
assert!(path.exists());

Examples found in repository

examples/create_new_project_dir.rs (line 25)

fn main() -> Result<(), OtToolsIoError> {
    let project_dirpath = PathBuf::from("example-new-project");

    std::fs::create_dir_all(&project_dirpath)?;

    let proj_fpath = project_dirpath.join("project.work");
    ProjectFile::default().to_data_file(&proj_fpath)?;

    let markers_fpath = project_dirpath.join("markers.work");
    MarkersFile::default().to_data_file(&markers_fpath)?;

    for i in 1..=16 {
        let bank_fpath = project_dirpath.join(bank_fname_from_id(i));
        BankFile::default().to_data_file(&bank_fpath)?;
    }

    for i in 1..=8 {
        let arr_fpath = project_dirpath.join(arr_fname_from_id(i));
        ArrangementFile::default().to_data_file(&arr_fpath)?;
    }

    println!("New project created: {project_dirpath:?}");
    Ok(())
}

examples/dbg_bank_scene_params.rs (line 25)

fn new_proj(banks: &[BankFile], proj_id: u32) -> Result<(), OtToolsIoError> {
    let project_dirpath = PathBuf::from("dbg").join(format!["PROJECT-{proj_id}"]);

    std::fs::create_dir_all(&project_dirpath)?;

    let proj_fpath = project_dirpath.join("project.work");
    ProjectFile::default().to_data_file(&proj_fpath)?;

    let markers_fpath = project_dirpath.join("markers.work");
    MarkersFile::default().to_data_file(&markers_fpath)?;

    for (idx, bank) in banks.iter().enumerate() {
        let bank_fpath = project_dirpath.join(bank_fname_from_id(idx + 1));
        bank.to_data_file(&bank_fpath)?;
    }

    for i in 1..=8 {
        let arr_fpath = project_dirpath.join(arr_fname_from_id(i));
        ArrangementFile::default().to_data_file(&arr_fpath)?;
    }

    println!("New project created: {project_dirpath:?}");
    Ok(())
}

fn to_bytes(&self) -> Result<Vec<u8>, OtToolsIoError>

Create bytes from type

// need to create everything from scratch in this example as many bytes otherwise
use serde::{Deserialize, Serialize};
use ot_tools_io::OctatrackFileIO;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Something {
    value: u8,
}

impl OctatrackFileIO for Something {}

let x = Something { value: 10 };
let r = x.to_bytes();
assert!(r.is_ok());
assert_eq!(r.unwrap(), [10]);

fn from_yaml_file(path: &Path) -> Result<Self, OtToolsIoError>

Read type from a YAML file at path

use ot_tools_io::{ProjectFile, OctatrackFileIO};
let project = ProjectFile::from_yaml_file(&path).unwrap();
assert_eq!(project.metadata.project_version, 19);

Examples found in repository

examples/read_bank_yaml.rs (line 14)

fn main() -> Result<(), OtToolsIoError> {
    let path = PathBuf::from("ot-tools-io")
        .join("test-data")
        .join("bank")
        .join("default.yaml");
    let data = BankFile::from_yaml_file(&path)?;

    println!("bank header: {:#?}", data.header);
    Ok(())
}

examples/read_markers_yaml.rs (line 14)

fn main() -> Result<(), OtToolsIoError> {
    let path = PathBuf::from("ot-tools-io")
        .join("test-data")
        .join("bank")
        .join("default.yaml");
    let data = MarkersFile::from_yaml_file(&path)?;

    println!("markers header: {:#?}", data.header);
    Ok(())
}

fn from_yaml_str(yaml: &str) -> Result<Self, OtToolsIoError>

Read type from YAML string

// need to create everything from scratch in this example
use serde::{Deserialize, Serialize};
use ot_tools_io::OctatrackFileIO;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Something {
    value: u8,
}

impl OctatrackFileIO for Something {}

let r = Something::from_yaml_str("value: 10\n");
assert!(r.is_ok());
assert_eq!(r.unwrap(), Something { value: 10 });

fn to_yaml_file(&self, path: &Path) -> Result<(), OtToolsIoError>

Write type to a YAML file at path

use ot_tools_io::{OctatrackFileIO, BankFile};
let r = BankFile::default().to_yaml_file(&path);
assert!(r.is_ok());
assert!(path.exists());

Examples found in repository

examples/project_bin_to_yaml.rs (line 13)

fn main() -> Result<(), OtToolsIoError> {
    let path = PathBuf::from("test-data")
        .join("blank-project")
        .join("project.work");
    let outpath = PathBuf::from("project.yaml");
    ProjectFile::from_data_file(&path)?.to_yaml_file(&outpath)?;
    println!("New yaml file written to {outpath:?}");
    Ok(())
}

fn to_yaml_string(&self) -> Result<String, OtToolsIoError>

Create YAML string from type

use ot_tools_io::{BankFile, OctatrackFileIO};
let bank = BankFile::default().to_yaml_string().unwrap();
assert_eq!(bank.len(), 12532024);
assert_eq!(bank[0..15], "header:\n- 70\n- ".to_string());

fn from_json_file(path: &Path) -> Result<Self, OtToolsIoError>

Read type from a JSON file at path

fn from_json_str(json: &str) -> Result<Self, OtToolsIoError>

Create type from JSON string

// need to create everything from scratch in this example
use serde::{Deserialize, Serialize};
use ot_tools_io::OctatrackFileIO;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Something {
    value: u8,
}

impl OctatrackFileIO for Something {}

let r = Something::from_json_str("{\"value\":10}");
assert!(r.is_ok());
assert_eq!(r.unwrap(), Something { value: 10 });

fn to_json_file(&self, path: &Path) -> Result<(), OtToolsIoError>

Write type to a JSON file at path

use ot_tools_io::{OctatrackFileIO, BankFile};
let r = BankFile::default().to_json_file(&path);
assert!(r.is_ok());
assert!(path.exists());

Examples found in repository

examples/project_bin_to_json.rs (line 14)

fn main() -> Result<(), OtToolsIoError> {
    let path = PathBuf::from("test-data")
        .join("blank-project")
        .join("project.work");
    let outpath = PathBuf::from("project.json");
    ProjectFile::from_data_file(&path)?.to_json_file(&outpath)?;
    println!("New json file written to {outpath:?}");
    Ok(())
}

fn to_json_string(&self) -> Result<String, OtToolsIoError>

Create JSON string from type

use ot_tools_io::{BankFile, OctatrackFileIO};
let json = BankFile::default().to_json_string().unwrap();
assert_eq!(json.len(), 7761363);
assert_eq!(json[0..15], "{\"header\":[70,7".to_string());

fn encode(&self) -> Result<Vec<u8>, OtToolsIoError>

where Self: Serialize,

Adds serialization via bincode and serde to a type. Must be present on all major file types.

use std::error::Error;
use ot_tools_io::OctatrackFileIO;

#[derive(serde::Deserialize, serde::Serialize, std::fmt::Debug)]
struct SomeType {
    x: u8,
    y: u32,
}

// default implementation
impl OctatrackFileIO for SomeType {}

let x = SomeType { x : 8, y: 32857983 };
let encoded = x.encode().unwrap();
assert_eq!(
    vec![8, 127, 95, 245, 1],
    encoded,
);

fn decode(bytes: &[u8]) -> Result<Self, OtToolsIoError>

where Self: Sized + for<'a> Deserialize<'a>,

Deserialization via bincode and serde.

use std::error::Error;
use ot_tools_io::{OctatrackFileIO, OtToolsIoError};

#[derive(serde::Deserialize, serde::Serialize, std::fmt::Debug, PartialEq)]
struct SomeType {
    x: u8,
    y: u32,
}

// default implementation
impl OctatrackFileIO for SomeType {}

let bytes: Vec<u8> = vec![8, 127, 95, 245, 1];
let decoded = SomeType::decode(&bytes).unwrap();

assert_eq!(
    SomeType { x : 8, y: 32857983 },
    decoded,
);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl OctatrackFileIO for ArrangementFile

impl OctatrackFileIO for BankFile

impl OctatrackFileIO for MarkersFile

impl OctatrackFileIO for ProjectFile

impl OctatrackFileIO for SampleSettingsFile