Struct MnxDocumentGlobalMeasuresItem 

pub struct MnxDocumentGlobalMeasuresItem {
    pub barline: Option<MnxDocumentGlobalMeasuresItemBarline>,
    pub ending: Option<MnxDocumentGlobalMeasuresItemEnding>,
    pub fine: Option<MnxDocumentGlobalMeasuresItemFine>,
    pub index: Option<MeasureNumber>,
    pub jump: Option<MnxDocumentGlobalMeasuresItemJump>,
    pub key: Option<MnxDocumentGlobalMeasuresItemKey>,
    pub number: Option<MeasureNumber>,
    pub repeat_end: Option<MnxDocumentGlobalMeasuresItemRepeatEnd>,
    pub repeat_start: Option<MnxDocumentGlobalMeasuresItemRepeatStart>,
    pub segno: Option<MnxDocumentGlobalMeasuresItemSegno>,
    pub tempos: Vec<MnxDocumentGlobalMeasuresItemTemposItem>,
    pub time: Option<MnxDocumentGlobalMeasuresItemTime>,
}

MnxDocumentGlobalMeasuresItem

JSON schema

{
 "type": "object",
 "properties": {
   "barline": {
     "type": "object",
     "required": [
       "type"
     ],
     "properties": {
       "type": {
         "type": "string",
         "enum": [
           "regular",
           "dotted",
           "dashed",
           "heavy",
           "double",
           "final",
           "heavyLight",
           "heavyHeavy",
           "tick",
           "short",
           "noBarline"
         ]
       }
     },
     "additionalProperties": false
   },
   "ending": {
     "type": "object",
     "required": [
       "duration"
     ],
     "properties": {
       "class": {
         "$ref": "#/$defs/style-class"
       },
       "color": {
         "$ref": "#/$defs/color"
       },
       "duration": {
         "type": "integer"
       },
       "numbers": {
         "type": "array",
         "items": {
           "type": "integer"
         }
       },
       "open": {
         "type": "boolean"
       }
     },
     "additionalProperties": false
   },
   "fine": {
     "type": "object",
     "required": [
       "location"
     ],
     "properties": {
       "class": {
         "$ref": "#/$defs/style-class"
       },
       "color": {
         "$ref": "#/$defs/color"
       },
       "location": {
         "$ref": "#/$defs/rhythmic-position"
       }
     },
     "additionalProperties": false
   },
   "index": {
     "$ref": "#/$defs/measure-number"
   },
   "jump": {
     "type": "object",
     "required": [
       "location",
       "type"
     ],
     "properties": {
       "location": {
         "$ref": "#/$defs/rhythmic-position"
       },
       "type": {
         "type": "string",
         "enum": [
           "dsalfine",
           "segno"
         ]
       }
     },
     "additionalProperties": false
   },
   "key": {
     "type": "object",
     "required": [
       "fifths"
     ],
     "properties": {
       "class": {
         "$ref": "#/$defs/style-class"
       },
       "color": {
         "$ref": "#/$defs/color"
       },
       "fifths": {
         "type": "integer"
       }
     },
     "additionalProperties": false
   },
   "number": {
     "$ref": "#/$defs/measure-number"
   },
   "repeatEnd": {
     "type": "object",
     "properties": {
       "times": {
         "type": "integer"
       }
     },
     "additionalProperties": false
   },
   "repeatStart": {
     "type": "object",
     "additionalProperties": false
   },
   "segno": {
     "type": "object",
     "required": [
       "location"
     ],
     "properties": {
       "class": {
         "$ref": "#/$defs/style-class"
       },
       "color": {
         "$ref": "#/$defs/color"
       },
       "glyph": {
         "$ref": "#/$defs/smufl-glyph"
       },
       "location": {
         "$ref": "#/$defs/rhythmic-position"
       }
     },
     "additionalProperties": false
   },
   "tempos": {
     "type": "array",
     "items": {
       "type": "object",
       "required": [
         "bpm",
         "value"
       ],
       "properties": {
         "bpm": {
           "type": "integer"
         },
         "location": {
           "$ref": "#/$defs/rhythmic-position"
         },
         "value": {
           "$ref": "#/$defs/note-value"
         }
       },
       "additionalProperties": false
     }
   },
   "time": {
     "type": "object",
     "required": [
       "count",
       "unit"
     ],
     "properties": {
       "count": {
         "$ref": "#/$defs/positive-integer"
       },
       "unit": {
         "type": "integer",
         "enum": [
           1,
           2,
           4,
           8,
           16,
           32,
           64,
           128
         ]
       }
     },
     "additionalProperties": false
   }
 },
 "additionalProperties": false
}

Fields

barline: Option<MnxDocumentGlobalMeasuresItemBarline>

ending: Option<MnxDocumentGlobalMeasuresItemEnding>

fine: Option<MnxDocumentGlobalMeasuresItemFine>

index: Option<MeasureNumber>

jump: Option<MnxDocumentGlobalMeasuresItemJump>

key: Option<MnxDocumentGlobalMeasuresItemKey>

number: Option<MeasureNumber>

repeat_end: Option<MnxDocumentGlobalMeasuresItemRepeatEnd>

repeat_start: Option<MnxDocumentGlobalMeasuresItemRepeatStart>

segno: Option<MnxDocumentGlobalMeasuresItemSegno>

tempos: Vec<MnxDocumentGlobalMeasuresItemTemposItem>

time: Option<MnxDocumentGlobalMeasuresItemTime>

Implementations

impl MnxDocumentGlobalMeasuresItem

pub fn builder() -> MnxDocumentGlobalMeasuresItem

Trait Implementations

impl Clone for MnxDocumentGlobalMeasuresItem

fn clone(&self) -> MnxDocumentGlobalMeasuresItem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MnxDocumentGlobalMeasuresItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MnxDocumentGlobalMeasuresItem

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MnxDocumentGlobalMeasuresItem

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&MnxDocumentGlobalMeasuresItem> for MnxDocumentGlobalMeasuresItem

fn from(value: &MnxDocumentGlobalMeasuresItem) -> Self

Converts to this type from the input type.

impl From<MnxDocumentGlobalMeasuresItem> for MnxDocumentGlobalMeasuresItem

fn from(value: MnxDocumentGlobalMeasuresItem) -> Self

Converts to this type from the input type.

impl Serialize for MnxDocumentGlobalMeasuresItem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<MnxDocumentGlobalMeasuresItem> for MnxDocumentGlobalMeasuresItem

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: MnxDocumentGlobalMeasuresItem, ) -> Result<Self, ConversionError>

Performs the conversion.