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
118
119
120

use super::{TuningAlter, TuningOctave, TuningStep};
use crate::datatypes::StringNumber;
use alloc::{string::String, vec::Vec};
use musicxml_internal::*;
use musicxml_macros::*;

/// Attributes pertaining to the [Accord] element.
#[derive(Debug, Default, PartialEq, Eq, AttributeDeserialize, AttributeSerialize)]
pub struct AccordAttributes {
  /// Strings are numbered from high to low.
  pub string: Option<StringNumber>,
}

/// Contents of the [Accord] element.
#[derive(Debug, PartialEq, Eq, ContentDeserialize, ContentSerialize)]
pub struct AccordContents {
  /// Step on a diatonic scale, represented using the English letters A through G.
  pub tuning_step: TuningStep,
  /// Number of semitones to alter the pitch from the tuning step.
  pub tuning_alter: Option<TuningAlter>,
  /// Octave number for the tuning of the string.
  pub tuning_octave: TuningOctave,
}

/// The [Accord] element represents the tuning of a single string in the [Scordatura][super::Scordatura] element.
///
/// It uses the same group of elements as the [StaffTuning][super::StaffTuning] element.
#[derive(Debug, PartialEq, Eq, ElementDeserialize, ElementSerialize)]
pub struct Accord {
  /// Element-specific attributes
  pub attributes: AccordAttributes,
  #[flatten]
  /// Element-specific content
  pub content: AccordContents,
}

#[cfg(test)]
mod accord_tests {
  use super::*;
  use crate::datatypes::{Octave, Semitones, Step};
  use crate::parser::{parse_from_xml_str, parse_to_xml_str};

  #[test]
  fn deserialize_valid1() {
    let result = parse_from_xml_str::<Accord>(
      "
      <accord string=\"1\">
        <tuning-step>D</tuning-step>
        <tuning-alter>-1</tuning-alter>
        <tuning-octave>4</tuning-octave>
      </accord>",
    );
    assert!(result.is_ok());
    assert_eq!(
      result.unwrap(),
      Accord {
        attributes: AccordAttributes {
          string: Some(StringNumber(1)),
        },
        content: AccordContents {
          tuning_step: TuningStep {
            attributes: (),
            content: Step::D
          },
          tuning_alter: Some(TuningAlter {
            attributes: (),
            content: Semitones(-1)
          }),
          tuning_octave: TuningOctave {
            attributes: (),
            content: Octave(4)
          },
        }
      }
    );
  }

  #[test]
  fn deserialize_invalid1() {
    let result = parse_from_xml_str::<Accord>(
      "
      <accord string=\"1\">
        <tuning-step>D</tuning-step>
        <tuning-alter>-1</tuning-alter>
        <tuning-octave>10</tuning-octave>
      </accord>",
    );
    assert!(result.is_err());
  }

  #[test]
  fn serialize_valid1() {
    let expected = "<accord string=\"1\">
  <tuning-step>D</tuning-step>
  <tuning-alter>-1</tuning-alter>
  <tuning-octave>4</tuning-octave>
</accord>";
    let test = Accord {
      attributes: AccordAttributes {
        string: Some(StringNumber(1)),
      },
      content: AccordContents {
        tuning_step: TuningStep {
          attributes: (),
          content: Step::D,
        },
        tuning_alter: Some(TuningAlter {
          attributes: (),
          content: Semitones(-1),
        }),
        tuning_octave: TuningOctave {
          attributes: (),
          content: Octave(4),
        },
      },
    };
    let result = parse_to_xml_str(&test, true);
    assert_eq!(result, expected);
  }
}