musicxml 1.1.2

MusicXML parsing, manipulation, and export library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use alloc::{string::String, string::ToString, vec::Vec};
use core::ops::Deref;
use musicxml_internal::{DatatypeDeserializer, DatatypeSerializer};

/// Comma-separated list of font names.
///
/// These can be specific font styles such as Maestro or Opus, or one of several generic
/// font styles: music, engraved, handwritten, text, serif, sans-serif, handwritten, cursive,
/// fantasy, and monospace.
///
/// The music, engraved, and handwritten values refer to music fonts; the rest refer to text fonts.
/// The fantasy style refers to decorative text such as found in older German-style printing.
///
/// The value of an instance of this type may be accessed by dereferencing the struct: `*datatype_val`.
#[derive(Debug, PartialEq, Eq)]
pub struct FontFamily(pub Vec<String>);

impl Deref for FontFamily {
  type Target = Vec<String>;
  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

impl DatatypeSerializer for FontFamily {
  fn serialize(element: &Self) -> String {
    element.0.join(",")
  }
}

impl DatatypeDeserializer for FontFamily {
  fn deserialize(value: &str) -> Result<Self, String> {
    let mut res: Vec<String> = Vec::new();
    value.split(',').for_each(|item| {
      let val = item.trim();
      if !val.is_empty() {
        res.push(val.to_string());
      }
    });
    Ok(FontFamily(res))
  }
}

#[cfg(test)]
mod font_family_tests {
  use super::*;

  #[test]
  fn serialize_valid1() {
    let test = FontFamily(vec![
      String::from("Ariel"),
      String::from("Times New Roman"),
      String::from("Courier"),
    ]);
    let result = FontFamily::serialize(&test);
    assert_eq!(result, "Ariel,Times New Roman,Courier");
  }

  #[test]
  fn serialize_valid2() {
    let test = FontFamily(vec![String::from("Ariel")]);
    let result = FontFamily::serialize(&test);
    assert_eq!(result, "Ariel");
  }

  #[test]
  fn deserialize_valid1() {
    let result = FontFamily::deserialize("Ariel");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), FontFamily(vec![String::from("Ariel")]));
  }

  #[test]
  fn deserialize_valid2() {
    let result = FontFamily::deserialize("Ariel,Times New Roman");
    assert!(result.is_ok());
    assert_eq!(
      result.unwrap(),
      FontFamily(vec![String::from("Ariel"), String::from("Times New Roman")])
    );
  }

  #[test]
  fn deserialize_valid3() {
    let result = FontFamily::deserialize("Ariel, Courier,Helvetica");
    assert!(result.is_ok());
    assert_eq!(
      result.unwrap(),
      FontFamily(vec![
        String::from("Ariel"),
        String::from("Courier"),
        String::from("Helvetica")
      ])
    );
  }

  #[test]
  fn deserialize_valid4() {
    let result = FontFamily::deserialize(",Ariel, Courier,Helvetica");
    assert!(result.is_ok());
    assert_eq!(
      result.unwrap(),
      FontFamily(vec![
        String::from("Ariel"),
        String::from("Courier"),
        String::from("Helvetica")
      ])
    );
  }

  #[test]
  fn deserialize_valid5() {
    let result = FontFamily::deserialize(",Ariel");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), FontFamily(vec![String::from("Ariel")]));
  }
}