Trait OctatrackFileIO 

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

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>) -> Result<(), Box<dyn Error>>

where Self: Debug,

Read type from an Octatrack data file at path

use ot_tools_io::{BankFile, OctatrackFileIO};
assert!(BankFile::from_data_file(&path).unwrap().repr(None).is_ok());
assert!(BankFile::from_data_file(&path).unwrap().repr(Some(false)).is_ok());
assert!(BankFile::from_data_file(&path).unwrap().repr(Some(true)).is_ok());

Examples found in repository

examples/project_bin_repr.rs (line 21)

fn main() -> RBoxErr<()> {
    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)
}

fn from_data_file(path: &Path) -> Result<Self, Box<dyn Error>>

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/project_bin_repr.rs (line 21)

fn main() -> RBoxErr<()> {
    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)
}

examples/project_bin_to_json.rs (line 15)

fn main() -> RBoxErr<()> {
    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 15)

fn main() -> RBoxErr<()> {
    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 18)

fn arrangement_check() -> RBoxErr<()> {
    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() -> RBoxErr<()> {
    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() -> RBoxErr<()> {
    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() -> RBoxErr<()> {
    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 22)

fn main() -> RBoxErr<()> {
    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(())
}

examples/read_project_files.rs (line 27)

fn main() -> RBoxErr<()> {
    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");

    let arr_fpath = blank_project_dirpath.join("arr01.work");
    let bank_fpath = blank_project_dirpath.join("bank01.work");
    let markers_fpath = blank_project_dirpath.join("markers.work");
    let project_fpath = blank_project_dirpath.join("project.work");

    let arr = ArrangementFile::from_data_file(&arr_fpath)?;
    let bank = BankFile::from_data_file(&bank_fpath)?;
    let markers = MarkersFile::from_data_file(&markers_fpath)?;
    let project = ProjectFile::from_data_file(&project_fpath)?;

    let arr_meta = Metadata {
        header: String::from_utf8_lossy(&arr.header)
            .to_string()
            .replace("\0", "."),
        datatype_version: arr.datatype_version,
    };

    let bank_meta = Metadata {
        header: String::from_utf8_lossy(&bank.header)
            .to_string()
            .replace("\0", "."),
        datatype_version: bank.datatype_version,
    };

    let markers_meta = Metadata {
        header: String::from_utf8_lossy(&markers.header)
            .to_string()
            .replace("\0", "."),
        datatype_version: markers.datatype_version,
    };

    println!("===================================");
    println!("| Printing example files metadata |");
    println!("===================================");
    println!();
    println!("project: {:#?}", project.metadata);
    println!();
    println!("arrangement: {arr_meta:#?}");
    println!();
    println!("bank: {bank_meta:#?}");
    println!();
    println!("markers: {markers_meta:#?}");
    Ok(())
}

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

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::{Decode, Encode, OctatrackFileIO};

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

impl Decode for Something {}
impl Encode for Something {}
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<(), Box<dyn Error>>

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() -> RBoxErr<()> {
    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) -> RBoxErr<()> {
    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>, Box<dyn Error>>

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::{Decode, Encode, OctatrackFileIO};

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

impl Decode for Something {}
impl Encode for Something {}
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, Box<dyn Error>>

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);

fn from_yaml_str(yaml: &str) -> Result<Self, Box<dyn Error>>

Read type from YAML string

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

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

impl Decode for Something {}
impl Encode for Something {}
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<(), Box<dyn Error>>

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 15)

fn main() -> RBoxErr<()> {
    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, Box<dyn Error>>

Create YAML string from type

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

fn from_json_file(path: &Path) -> Result<Self, Box<dyn Error>>

Read type from a JSON file at path

fn from_json_str(json: &str) -> Result<Self, Box<dyn Error>>

Create type from JSON string

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

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

impl Decode for Something {}
impl Encode for Something {}
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<(), Box<dyn Error>>

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 15)

fn main() -> RBoxErr<()> {
    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, Box<dyn Error>>

Create JSON string from type

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

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