Struct MnxDocumentPartsItem 

pub struct MnxDocumentPartsItem {
    pub id: Option<Id>,
    pub measures: Vec<MnxDocumentPartsItemMeasuresItem>,
    pub name: Option<String>,
    pub short_name: Option<String>,
    pub smufl_font: Option<SmuflFont>,
    pub staves: Option<i64>,
}

MnxDocumentPartsItem

JSON schema

{
 "type": "object",
 "properties": {
   "id": {
     "$ref": "#/$defs/id"
   },
   "measures": {
     "type": "array",
     "items": {
       "type": "object",
       "required": [
         "sequences"
       ],
       "properties": {
         "beams": {
           "$ref": "#/$defs/beam-list"
         },
         "clefs": {
           "type": "array",
           "items": {
             "type": "object",
             "required": [
               "clef"
             ],
             "properties": {
               "clef": {
                 "type": "object",
                 "required": [
                   "sign",
                   "staffPosition"
                 ],
                 "properties": {
                   "class": {
                     "$ref": "#/$defs/style-class"
                   },
                   "color": {
                     "type": "string"
                   },
                   "glyph": {
                     "$ref": "#/$defs/smufl-glyph"
                   },
                   "octave": {
                     "type": "integer"
                   },
                   "sign": {
                     "type": "string",
                     "enum": [
                       "C",
                       "F",
                       "G"
                     ]
                   },
                   "staffPosition": {
                     "$ref": "#/$defs/staff-position"
                   }
                 },
                 "additionalProperties": false
               },
               "position": {
                 "$ref": "#/$defs/rhythmic-position"
               },
               "staff": {
                 "$ref": "#/$defs/staff-number"
               }
             },
             "additionalProperties": false
           }
         },
         "dynamics": {
           "type": "array",
           "items": {
             "type": "object",
             "required": [
               "position",
               "value"
             ],
             "properties": {
               "glyph": {
                 "$ref": "#/$defs/smufl-glyph"
               },
               "position": {
                 "$ref": "#/$defs/rhythmic-position"
               },
               "staff": {
                 "$ref": "#/$defs/staff-number"
               },
               "value": {
                 "type": "string"
               },
               "voice": {
                 "$ref": "#/$defs/voice-name"
               }
             },
             "additionalProperties": false
           }
         },
         "ottavas": {
           "type": "array",
           "items": {
             "type": "object",
             "required": [
               "end",
               "position",
               "value"
             ],
             "properties": {
               "end": {
                 "$ref": "#/$defs/measure-rhythmic-position"
               },
               "orient": {
                 "$ref": "#/$defs/orientation"
               },
               "position": {
                 "$ref": "#/$defs/rhythmic-position"
               },
               "staff": {
                 "$ref": "#/$defs/staff-number"
               },
               "value": {
                 "type": "integer",
                 "enum": [
                   1,
                   2,
                   -1,
                   -2,
                   3,
                   -3
                 ]
               },
               "voice": {
                 "$ref": "#/$defs/voice-name"
               }
             },
             "additionalProperties": false
           }
         },
         "sequences": {
           "type": "array",
           "items": {
             "type": "object",
             "required": [
               "content"
             ],
             "properties": {
               "content": {
                 "$ref": "#/$defs/sequence-content"
               },
               "orient": {
                 "$ref": "#/$defs/orientation"
               },
               "staff": {
                 "$ref": "#/$defs/staff-number"
               },
               "voice": {
                 "$ref": "#/$defs/voice-name"
               }
             },
             "additionalProperties": false
           }
         }
       },
       "additionalProperties": false
     }
   },
   "name": {
     "type": "string"
   },
   "shortName": {
     "type": "string"
   },
   "smuflFont": {
     "$ref": "#/$defs/smufl-font"
   },
   "staves": {
     "type": "integer"
   }
 },
 "additionalProperties": false
}

Fields

id: Option<Id>

measures: Vec<MnxDocumentPartsItemMeasuresItem>

name: Option<String>

short_name: Option<String>

smufl_font: Option<SmuflFont>

staves: Option<i64>

Implementations

impl MnxDocumentPartsItem

pub fn builder() -> MnxDocumentPartsItem

Trait Implementations

impl Clone for MnxDocumentPartsItem

fn clone(&self) -> MnxDocumentPartsItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MnxDocumentPartsItem

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

Formats the value using the given formatter.

impl Default for MnxDocumentPartsItem

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MnxDocumentPartsItem

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&MnxDocumentPartsItem> for MnxDocumentPartsItem

fn from(value: &MnxDocumentPartsItem) -> Self

Converts to this type from the input type.

impl From<MnxDocumentPartsItem> for MnxDocumentPartsItem

fn from(value: MnxDocumentPartsItem) -> Self

Converts to this type from the input type.

impl Serialize for MnxDocumentPartsItem

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<MnxDocumentPartsItem> for MnxDocumentPartsItem

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.