ot_tools_io

Trait OctatrackFileIO

Source 
pub trait OctatrackFileIO:
    Decode
    + Encode
    + Serialize
    + for<'a> Deserialize<'a> {

Show 13 methods    // 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>> { ... }

}
Expand description

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§

Source

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)
18fn main() -> RBoxErr<()> {
19    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
20    let project_fpath = blank_project_dirpath.join("project.work");
21    ProjectFile::from_data_file(&project_fpath)?.repr(None)
22}
Source

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)
18fn main() -> RBoxErr<()> {
19    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
20    let project_fpath = blank_project_dirpath.join("project.work");
21    ProjectFile::from_data_file(&project_fpath)?.repr(None)
22}
More examples
Hide additional examples
examples/project_bin_to_json.rs (line 15)
10fn main() -> RBoxErr<()> {
11    let path = PathBuf::from("test-data")
12        .join("blank-project")
13        .join("project.work");
14    let outpath = PathBuf::from("project.json");
15    ProjectFile::from_data_file(&path)?.to_json_file(&outpath)?;
16    println!("New json file written to {outpath:?}");
17    Ok(())
18}
examples/project_bin_to_yaml.rs (line 15)
10fn main() -> RBoxErr<()> {
11    let path = PathBuf::from("test-data")
12        .join("blank-project")
13        .join("project.work");
14    let outpath = PathBuf::from("project.yaml");
15    ProjectFile::from_data_file(&path)?.to_yaml_file(&outpath)?;
16    println!("New yaml file written to {outpath:?}");
17    Ok(())
18}
examples/check_checksums.rs (line 18)
14fn arrangement_check() -> RBoxErr<()> {
15    let fp = PathBuf::from("test-data")
16        .join("arrange")
17        .join("full-options.work");
18    let bin = ArrangementFile::from_data_file(&fp)?;
19    println!("checksum from arrangement file: {:?}", bin.checksum);
20
21    let checksum = bin.calculate_checksum()?;
22    println!("calculated checksum for arrangement file: {checksum:?}");
23
24    if bin.check_checksum()? {
25        println!("arrangement file checksum is ok");
26    } else {
27        println!("bad arrangement file checksum");
28        panic!()
29    };
30    Ok(())
31}
32
33fn bank_check() -> RBoxErr<()> {
34    let fp = PathBuf::from("test-data")
35        .join("blank-project")
36        .join("bank01.work");
37    let bin = BankFile::from_data_file(&fp)?;
38    println!("checksum from bank file: {:?}", bin.checksum);
39
40    let checksum = bin.calculate_checksum()?;
41    println!("calculated checksum for bank file: {checksum:?}");
42
43    if bin.check_checksum()? {
44        println!("bank file checksum is ok");
45    } else {
46        println!("bad bank file checksum");
47        panic!()
48    };
49    Ok(())
50}
51
52fn markers_check() -> RBoxErr<()> {
53    let fp = PathBuf::from("test-data")
54        .join("blank-project")
55        .join("markers.work");
56    let bin = ArrangementFile::from_data_file(&fp)?;
57    println!("checksum from markers file: {:?}", bin.checksum);
58
59    let checksum = bin.calculate_checksum()?;
60    println!("calculated checksum for markers file: {checksum:?}");
61
62    if bin.check_checksum()? {
63        println!("markers file checksum is ok");
64    } else {
65        println!("bad markers file checksum");
66        panic!()
67    };
68
69    Ok(())
70}
71
72fn sample_check() -> RBoxErr<()> {
73    let fp = PathBuf::from("test-data").join("samples").join("sample.ot");
74    let bin = SampleSettingsFile::from_data_file(&fp)?;
75    println!("checksum from sample settings file: {:?}", bin.checksum);
76
77    let checksum = bin.calculate_checksum()?;
78    println!("calculated checksum for sample settings file: {checksum:?}");
79
80    if bin.check_checksum()? {
81        println!("sample settings file checksum is ok");
82    } else {
83        println!("bad sample settings file checksum");
84        panic!()
85    };
86    Ok(())
87}
examples/list_sample_slots.rs (line 22)
19fn main() -> RBoxErr<()> {
20    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
21    let project_fpath = blank_project_dirpath.join("project.work");
22    let project = ProjectFile::from_data_file(&project_fpath)?;
23
24    println!("====================================");
25    println!("|       Project Sample Slots       |");
26    println!("====================================");
27    println!("-------------- Static --------------");
28    for (idx, sample_slot) in project.slots.static_slots.iter().enumerate() {
29        println!("Static Slot {}: {sample_slot:?}", idx + 1)
30    }
31    println!("--------------- Flex ---------------");
32    for (idx, sample_slot) in project.slots.flex_slots.iter().enumerate() {
33        println!("Flex Slot {}: {sample_slot:?}", idx + 1)
34    }
35    Ok(())
36}
examples/read_project_files.rs (line 27)
19fn main() -> RBoxErr<()> {
20    let blank_project_dirpath = PathBuf::from("test-data").join("blank-project");
21
22    let arr_fpath = blank_project_dirpath.join("arr01.work");
23    let bank_fpath = blank_project_dirpath.join("bank01.work");
24    let markers_fpath = blank_project_dirpath.join("markers.work");
25    let project_fpath = blank_project_dirpath.join("project.work");
26
27    let arr = ArrangementFile::from_data_file(&arr_fpath)?;
28    let bank = BankFile::from_data_file(&bank_fpath)?;
29    let markers = MarkersFile::from_data_file(&markers_fpath)?;
30    let project = ProjectFile::from_data_file(&project_fpath)?;
31
32    let arr_meta = Metadata {
33        header: String::from_utf8_lossy(&arr.header)
34            .to_string()
35            .replace("\0", "."),
36        datatype_version: arr.datatype_version,
37    };
38
39    let bank_meta = Metadata {
40        header: String::from_utf8_lossy(&bank.header)
41            .to_string()
42            .replace("\0", "."),
43        datatype_version: bank.datatype_version,
44    };
45
46    let markers_meta = Metadata {
47        header: String::from_utf8_lossy(&markers.header)
48            .to_string()
49            .replace("\0", "."),
50        datatype_version: markers.datatype_version,
51    };
52
53    println!("===================================");
54    println!("| Printing example files metadata |");
55    println!("===================================");
56    println!();
57    println!("project: {:#?}", project.metadata);
58    println!();
59    println!("arrangement: {arr_meta:#?}");
60    println!();
61    println!("bank: {bank_meta:#?}");
62    println!();
63    println!("markers: {markers_meta:#?}");
64    Ok(())
65}
Source

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

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)
19fn main() -> RBoxErr<()> {
20    let project_dirpath = PathBuf::from("example-new-project");
21
22    std::fs::create_dir_all(&project_dirpath)?;
23
24    let proj_fpath = project_dirpath.join("project.work");
25    ProjectFile::default().to_data_file(&proj_fpath)?;
26
27    let markers_fpath = project_dirpath.join("markers.work");
28    MarkersFile::default().to_data_file(&markers_fpath)?;
29
30    for i in 1..=16 {
31        let bank_fpath = project_dirpath.join(bank_fname_from_id(i));
32        BankFile::default().to_data_file(&bank_fpath)?;
33    }
34
35    for i in 1..=8 {
36        let arr_fpath = project_dirpath.join(arr_fname_from_id(i));
37        ArrangementFile::default().to_data_file(&arr_fpath)?;
38    }
39
40    println!("New project created: {project_dirpath:?}");
41    Ok(())
42}
Source

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

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

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

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)
10fn main() -> RBoxErr<()> {
11    let path = PathBuf::from("test-data")
12        .join("blank-project")
13        .join("project.work");
14    let outpath = PathBuf::from("project.yaml");
15    ProjectFile::from_data_file(&path)?.to_yaml_file(&outpath)?;
16    println!("New yaml file written to {outpath:?}");
17    Ok(())
18}
Source

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

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

Read type from a JSON file at path

Source

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

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)
10fn main() -> RBoxErr<()> {
11    let path = PathBuf::from("test-data")
12        .join("blank-project")
13        .join("project.work");
14    let outpath = PathBuf::from("project.json");
15    ProjectFile::from_data_file(&path)?.to_json_file(&outpath)?;
16    println!("New json file written to {outpath:?}");
17    Ok(())
18}
Source

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§