Skip to content

Instantly share code, notes, and snippets.

@benhall-7

benhall-7/expanded.rs

Created May 26, 2020 19:16
Show Gist options
  • Save benhall-7/3057fcf02f74a7c2acc34d66748f028a to your computer and use it in GitHub Desktop.
Save benhall-7/3057fcf02f74a7c2acc34d66748f028a to your computer and use it in GitHub Desktop.
Download ZIP
musicli macro expansion
Raw
expanded.rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
pub mod error {
use std::error;
use std::fmt::Display;
use std::io;
pub enum Error {
IO(io::Error),
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Error {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&Error::IO(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("IO");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
}
}
}
impl From<io::Error> for Error {
fn from(err: io::Error) -> Self {
Error::IO(err)
}
}
impl Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
match self {
Error::IO(e) => f.write_fmt(::core::fmt::Arguments::new_v1(
&["IO error: "],
&match (&e,) {
(arg0,) => [::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt)],
},
)),
}
}
}
impl error::Error for Error {
fn cause(&self) -> Option<&dyn error::Error> {
match self {
Error::IO(e) => Some(e),
}
}
}
}
pub mod midi {
mod file {
use super::{Format, Timing};
use crate::midi::Track;
use binread::io::{Read, Seek};
use binread::Endian::Big;
use binread::{BinRead, BinReaderExt, BinResult, ReadOptions};
use serde::{Deserialize, Serialize};
pub struct File {
pub format: Format,
timing: Timing,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for File {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
File {
format: ref __self_0_0,
timing: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("File");
let _ = debug_trait_builder.field("format", &&(*__self_0_0));
let _ = debug_trait_builder.field("timing", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_File: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for File {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"format" => _serde::export::Ok(__Field::__field0),
"timing" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"format" => _serde::export::Ok(__Field::__field0),
b"timing" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<File>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = File;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct File")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<Format>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct File with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<Timing>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct File with 2 elements",
));
}
};
_serde::export::Ok(File {
format: __field0,
timing: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Format> = _serde::export::None;
let mut __field1: _serde::export::Option<Timing> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"format",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Format>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"timing",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Timing>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("format") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("timing") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(File {
format: __field0,
timing: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["format", "timing"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"File",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<File>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_File: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for File {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"File",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"format",
&self.format,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"timing",
&self.timing,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
impl File {
pub fn get_timing(&self) -> Timing {
self.timing
}
}
impl BinRead for File {
type Args = ();
fn read_options<R: Read + Seek>(
reader: &mut R,
_: &ReadOptions,
_: (),
) -> BinResult<Self> {
let mut buf = [0u8; 4];
reader.read_exact(&mut buf)?;
{
match (&b"MThd", &&buf) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
&[
"assertion failed: `(left == right)`\n left: `",
"`,\n right: `",
"`",
],
&match (&&*left_val, &&*right_val) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Debug::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Debug::fmt,
),
],
},
))
}
}
}
}
};
let size = reader.read_type::<u32>(Big)?;
{
match (&size, &6) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
&[
"assertion failed: `(left == right)`\n left: `",
"`,\n right: `",
"`",
],
&match (&&*left_val, &&*right_val) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Debug::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Debug::fmt,
),
],
},
))
}
}
}
}
};
let format = reader.read_type::<u16>(Big)?;
let track_count = reader.read_type::<u16>(Big)?;
let timing = Timing::read(reader)?;
match format {
0 => Ok(File {
format: Format::SingleTrack(Track::read(reader)?),
timing,
}),
1 => {
let mut tracks = Vec::with_capacity(track_count as usize);
for _ in 0..track_count {
tracks.push(Track::read(reader)?);
}
Ok(File {
format: Format::MultipleTrack(tracks),
timing,
})
}
2 => {
let mut tracks = Vec::with_capacity(track_count as usize);
for _ in 0..track_count {
tracks.push(Track::read(reader)?);
}
Ok(File {
format: Format::ParallelTrack(tracks),
timing,
})
}
_ => ::std::rt::begin_panic(
"MIDI format specifier only allows values 0, 1, or 2",
),
}
}
}
}
mod format {
use super::Track;
use serde::{Deserialize, Serialize};
pub enum Format {
SingleTrack(Track),
MultipleTrack(Vec<Track>),
ParallelTrack(Vec<Track>),
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Format {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&Format::SingleTrack(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("SingleTrack");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&Format::MultipleTrack(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("MultipleTrack");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&Format::ParallelTrack(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("ParallelTrack");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Format: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Format {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"SingleTrack" => _serde::export::Ok(__Field::__field0),
"MultipleTrack" => _serde::export::Ok(__Field::__field1),
"ParallelTrack" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"SingleTrack" => _serde::export::Ok(__Field::__field0),
b"MultipleTrack" => _serde::export::Ok(__Field::__field1),
b"ParallelTrack" => _serde::export::Ok(__Field::__field2),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Format>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Format;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum Format")
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<Track>(__variant),
Format::SingleTrack,
),
(__Field::__field1, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<Vec<Track>>(
__variant,
),
Format::MultipleTrack,
),
(__Field::__field2, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<Vec<Track>>(
__variant,
),
Format::ParallelTrack,
),
}
}
}
const VARIANTS: &'static [&'static str] =
&["SingleTrack", "MultipleTrack", "ParallelTrack"];
_serde::Deserializer::deserialize_enum(
__deserializer,
"Format",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<Format>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Format: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Format {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
Format::SingleTrack(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"Format",
0u32,
"SingleTrack",
__field0,
)
}
Format::MultipleTrack(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"Format",
1u32,
"MultipleTrack",
__field0,
)
}
Format::ParallelTrack(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"Format",
2u32,
"ParallelTrack",
__field0,
)
}
}
}
}
};
}
mod smpte_timecode {
use serde::{Deserialize, Serialize};
pub enum SMPTETimecode {
FPS24 = 24,
FPS25 = 25,
FPS29 = 29,
FPS30 = 30,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for SMPTETimecode {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&SMPTETimecode::FPS24,) => {
let mut debug_trait_builder = f.debug_tuple("FPS24");
debug_trait_builder.finish()
}
(&SMPTETimecode::FPS25,) => {
let mut debug_trait_builder = f.debug_tuple("FPS25");
debug_trait_builder.finish()
}
(&SMPTETimecode::FPS29,) => {
let mut debug_trait_builder = f.debug_tuple("FPS29");
debug_trait_builder.finish()
}
(&SMPTETimecode::FPS30,) => {
let mut debug_trait_builder = f.debug_tuple("FPS30");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for SMPTETimecode {
#[inline]
fn clone(&self) -> SMPTETimecode {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::marker::Copy for SMPTETimecode {}
impl ::core::marker::StructuralPartialEq for SMPTETimecode {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for SMPTETimecode {
#[inline]
fn eq(&self, other: &SMPTETimecode) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => true,
}
} else {
false
}
}
}
}
impl ::core::marker::StructuralEq for SMPTETimecode {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for SMPTETimecode {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialOrd for SMPTETimecode {
#[inline]
fn partial_cmp(
&self,
other: &SMPTETimecode,
) -> ::core::option::Option<::core::cmp::Ordering> {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => ::core::option::Option::Some(::core::cmp::Ordering::Equal),
}
} else {
__self_vi.partial_cmp(&__arg_1_vi)
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Ord for SMPTETimecode {
#[inline]
fn cmp(&self, other: &SMPTETimecode) -> ::core::cmp::Ordering {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => ::core::cmp::Ordering::Equal,
}
} else {
__self_vi.cmp(&__arg_1_vi)
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_SMPTETimecode: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for SMPTETimecode {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 4",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"FPS24" => _serde::export::Ok(__Field::__field0),
"FPS25" => _serde::export::Ok(__Field::__field1),
"FPS29" => _serde::export::Ok(__Field::__field2),
"FPS30" => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"FPS24" => _serde::export::Ok(__Field::__field0),
b"FPS25" => _serde::export::Ok(__Field::__field1),
b"FPS29" => _serde::export::Ok(__Field::__field2),
b"FPS30" => _serde::export::Ok(__Field::__field3),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<SMPTETimecode>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = SMPTETimecode;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum SMPTETimecode")
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(SMPTETimecode::FPS24)
}
(__Field::__field1, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(SMPTETimecode::FPS25)
}
(__Field::__field2, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(SMPTETimecode::FPS29)
}
(__Field::__field3, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(SMPTETimecode::FPS30)
}
}
}
}
const VARIANTS: &'static [&'static str] = &["FPS24", "FPS25", "FPS29", "FPS30"];
_serde::Deserializer::deserialize_enum(
__deserializer,
"SMPTETimecode",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<SMPTETimecode>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_SMPTETimecode: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for SMPTETimecode {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
SMPTETimecode::FPS24 => _serde::Serializer::serialize_unit_variant(
__serializer,
"SMPTETimecode",
0u32,
"FPS24",
),
SMPTETimecode::FPS25 => _serde::Serializer::serialize_unit_variant(
__serializer,
"SMPTETimecode",
1u32,
"FPS25",
),
SMPTETimecode::FPS29 => _serde::Serializer::serialize_unit_variant(
__serializer,
"SMPTETimecode",
2u32,
"FPS29",
),
SMPTETimecode::FPS30 => _serde::Serializer::serialize_unit_variant(
__serializer,
"SMPTETimecode",
3u32,
"FPS30",
),
}
}
}
};
impl SMPTETimecode {
pub fn from(value: u32) -> Result<Self, ()> {
match value {
24 => Ok(SMPTETimecode::FPS24),
25 => Ok(SMPTETimecode::FPS25),
29 => Ok(SMPTETimecode::FPS29),
30 => Ok(SMPTETimecode::FPS30),
_ => Err(()),
}
}
}
}
mod timing {
use crate::midi::SMPTETimecode;
use binread::io::{Error, ErrorKind, Read, Seek};
use binread::Endian::Big;
use binread::{BinRead, BinReaderExt, BinResult, ReadOptions};
use serde::{Deserialize, Serialize};
pub enum Timing {
/// Indicates a subdivision of quarter notes into a number of pulses.
/// This timing is affected by tempo tracks, because it depends on the time of a quarter note.
Metrical(u16),
/// Indicates a subdivision of each second into frames.
/// A frame is subdivided once again by the second value.
/// This timing is not affected by tempo tracks.
Real(SMPTETimecode, u8),
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Timing {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&Timing::Metrical(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Metrical");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&Timing::Real(ref __self_0, ref __self_1),) => {
let mut debug_trait_builder = f.debug_tuple("Real");
let _ = debug_trait_builder.field(&&(*__self_0));
let _ = debug_trait_builder.field(&&(*__self_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Timing {
#[inline]
fn clone(&self) -> Timing {
{
let _: ::core::clone::AssertParamIsClone<u16>;
let _: ::core::clone::AssertParamIsClone<SMPTETimecode>;
let _: ::core::clone::AssertParamIsClone<u8>;
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::marker::Copy for Timing {}
impl ::core::marker::StructuralPartialEq for Timing {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Timing {
#[inline]
fn eq(&self, other: &Timing) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
(*__self_0) == (*__arg_1_0)
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => (*__self_0) == (*__arg_1_0) && (*__self_1) == (*__arg_1_1),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
false
}
}
}
#[inline]
fn ne(&self, other: &Timing) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
(*__self_0) != (*__arg_1_0)
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => (*__self_0) != (*__arg_1_0) || (*__self_1) != (*__arg_1_1),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
true
}
}
}
}
impl ::core::marker::StructuralEq for Timing {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for Timing {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<u16>;
let _: ::core::cmp::AssertParamIsEq<SMPTETimecode>;
let _: ::core::cmp::AssertParamIsEq<u8>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialOrd for Timing {
#[inline]
fn partial_cmp(&self, other: &Timing) -> ::core::option::Option<::core::cmp::Ordering> {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
match ::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
) {
::core::option::Option::Some(::core::cmp::Ordering::Equal) => {
::core::option::Option::Some(::core::cmp::Ordering::Equal)
}
cmp => cmp,
}
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => match ::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
) {
::core::option::Option::Some(::core::cmp::Ordering::Equal) => {
match ::core::cmp::PartialOrd::partial_cmp(
&(*__self_1),
&(*__arg_1_1),
) {
::core::option::Option::Some(
::core::cmp::Ordering::Equal,
) => ::core::option::Option::Some(
::core::cmp::Ordering::Equal,
),
cmp => cmp,
}
}
cmp => cmp,
},
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
__self_vi.partial_cmp(&__arg_1_vi)
}
}
}
#[inline]
fn lt(&self, other: &Timing) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Greater,
) == ::core::cmp::Ordering::Less
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => {
::core::cmp::Ordering::then_with(
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Equal,
),
|| {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_1),
&(*__arg_1_1),
),
::core::cmp::Ordering::Greater,
)
},
) == ::core::cmp::Ordering::Less
}
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
__self_vi.lt(&__arg_1_vi)
}
}
}
#[inline]
fn le(&self, other: &Timing) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Greater,
) != ::core::cmp::Ordering::Greater
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => {
::core::cmp::Ordering::then_with(
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Equal,
),
|| {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_1),
&(*__arg_1_1),
),
::core::cmp::Ordering::Greater,
)
},
) != ::core::cmp::Ordering::Greater
}
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
__self_vi.le(&__arg_1_vi)
}
}
}
#[inline]
fn gt(&self, other: &Timing) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Less,
) == ::core::cmp::Ordering::Greater
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => {
::core::cmp::Ordering::then_with(
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Equal,
),
|| {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_1),
&(*__arg_1_1),
),
::core::cmp::Ordering::Less,
)
},
) == ::core::cmp::Ordering::Greater
}
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
__self_vi.gt(&__arg_1_vi)
}
}
}
#[inline]
fn ge(&self, other: &Timing) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Less,
) != ::core::cmp::Ordering::Less
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => {
::core::cmp::Ordering::then_with(
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0),
&(*__arg_1_0),
),
::core::cmp::Ordering::Equal,
),
|| {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_1),
&(*__arg_1_1),
),
::core::cmp::Ordering::Less,
)
},
) != ::core::cmp::Ordering::Less
}
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
__self_vi.ge(&__arg_1_vi)
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Ord for Timing {
#[inline]
fn cmp(&self, other: &Timing) -> ::core::cmp::Ordering {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(&Timing::Metrical(ref __self_0), &Timing::Metrical(ref __arg_1_0)) => {
match ::core::cmp::Ord::cmp(&(*__self_0), &(*__arg_1_0)) {
::core::cmp::Ordering::Equal => ::core::cmp::Ordering::Equal,
cmp => cmp,
}
}
(
&Timing::Real(ref __self_0, ref __self_1),
&Timing::Real(ref __arg_1_0, ref __arg_1_1),
) => match ::core::cmp::Ord::cmp(&(*__self_0), &(*__arg_1_0)) {
::core::cmp::Ordering::Equal => {
match ::core::cmp::Ord::cmp(&(*__self_1), &(*__arg_1_1)) {
::core::cmp::Ordering::Equal => {
::core::cmp::Ordering::Equal
}
cmp => cmp,
}
}
cmp => cmp,
},
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
__self_vi.cmp(&__arg_1_vi)
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Timing: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Timing {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"Metrical" => _serde::export::Ok(__Field::__field0),
"Real" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"Metrical" => _serde::export::Ok(__Field::__field0),
b"Real" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Timing>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Timing;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum Timing")
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<u16>(__variant),
Timing::Metrical,
),
(__Field::__field1, __variant) => {
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Timing>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Timing;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"tuple variant Timing::Real",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
SMPTETimecode,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "tuple variant Timing::Real with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<u8>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "tuple variant Timing::Real with 2 elements" ) ) ;
}
};
_serde::export::Ok(Timing::Real(__field0, __field1))
}
}
_serde::de::VariantAccess::tuple_variant(
__variant,
2usize,
__Visitor {
marker: _serde::export::PhantomData::<Timing>,
lifetime: _serde::export::PhantomData,
},
)
}
}
}
}
const VARIANTS: &'static [&'static str] = &["Metrical", "Real"];
_serde::Deserializer::deserialize_enum(
__deserializer,
"Timing",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<Timing>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Timing: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Timing {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
Timing::Metrical(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"Timing",
0u32,
"Metrical",
__field0,
)
}
Timing::Real(ref __field0, ref __field1) => {
let mut __serde_state =
match _serde::Serializer::serialize_tuple_variant(
__serializer,
"Timing",
1u32,
"Real",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state,
__field0,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state,
__field1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeTupleVariant::end(__serde_state)
}
}
}
}
};
impl BinRead for Timing {
type Args = ();
fn read_options<R: Read + Seek>(
reader: &mut R,
_: &ReadOptions,
_: (),
) -> BinResult<Self> {
let short = reader.read_type::<i16>(Big)?;
if short > 0 {
Ok(Timing::Metrical(short as u16))
} else {
let timecode_amount = -((short >> 8) as i8);
let timecode = SMPTETimecode::from(timecode_amount as u32)
.or_else(|_| Err(Error::from(ErrorKind::InvalidData)))?;
Ok(Timing::Real(timecode, (short & 0xff) as u8))
}
}
}
}
mod track {
use super::event::{Event, EventWithRet};
use binread::io::{Read, Seek, SeekFrom};
use binread::Endian::Big;
use binread::{BinRead, BinReaderExt, BinResult, ReadOptions};
use serde::{Deserialize, Serialize};
#[br(magic = b"MTrk")]
pub struct Track {
# [ br ( parse_with = read_events ) ]
events: Vec<Event>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Track {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Track {
events: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("Track");
let _ = debug_trait_builder.field("events", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Track: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Track {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"events" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"events" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Track>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Track;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct Track")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<Event>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct Track with 1 element",
));
}
};
_serde::export::Ok(Track { events: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<Event>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"events",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Vec<Event>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("events") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(Track { events: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["events"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Track",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Track>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Track: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Track {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Track",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"events",
&self.events,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(warnings)]
impl ::binread::BinRead for Track {
type Args = ();
fn read_options<R: ::binread::io::Read + ::binread::io::Seek>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<Self> {
let () = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
::binread::error::magic(
__binread_generated_var_reader,
*b"MTrk",
__binread_generated_var_options,
)?;
let __events_binwrite_generated_args = ();
let __events_binwrite_generated_options = __binread_generated_var_options;
let mut events: Vec<Event> = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((read_events(
__binread_generated_var_reader,
__events_binwrite_generated_options,
__events_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__events_binwrite_generated_options,
__events_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut events,
__binread_generated_var_reader,
__events_binwrite_generated_options,
__events_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(Self { events })
}
fn after_parse<R: ::binread::io::Read + ::binread::io::Seek>(
&mut self,
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<()> {
Ok(())
}
}
fn read_events<R: Read + Seek>(
reader: &mut R,
ro: &ReadOptions,
_: (),
) -> BinResult<Vec<Event>> {
let length = reader.read_type::<u32>(Big)?;
let mut events = Vec::<Event>::new();
let end = reader.seek(SeekFrom::Current(0))? as u32 + length;
let mut running_status = None;
while (reader.seek(SeekFrom::Current(0))? as u32) < end {
let EventWithRet(event, status) =
EventWithRet::read_options(reader, ro, running_status)?;
running_status = status;
events.push(event);
}
Ok(events)
}
}
mod var_length_value {
use crate::utils::Bounded;
use binread::io::{Read, Seek, SeekFrom};
use binread::{BinRead, BinResult, ReadOptions};
use serde::{Deserialize, Serialize};
pub struct VarLengthValue(# [ br ( parse_with = read ) ] pub(crate) u32);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for VarLengthValue {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
VarLengthValue(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("VarLengthValue");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for VarLengthValue {
#[inline]
fn clone(&self) -> VarLengthValue {
{
let _: ::core::clone::AssertParamIsClone<u32>;
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::marker::Copy for VarLengthValue {}
impl ::core::marker::StructuralPartialEq for VarLengthValue {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for VarLengthValue {
#[inline]
fn eq(&self, other: &VarLengthValue) -> bool {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &VarLengthValue) -> bool {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for VarLengthValue {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for VarLengthValue {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<u32>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialOrd for VarLengthValue {
#[inline]
fn partial_cmp(
&self,
other: &VarLengthValue,
) -> ::core::option::Option<::core::cmp::Ordering> {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => {
match ::core::cmp::PartialOrd::partial_cmp(
&(*__self_0_0),
&(*__self_1_0),
) {
::core::option::Option::Some(::core::cmp::Ordering::Equal) => {
::core::option::Option::Some(::core::cmp::Ordering::Equal)
}
cmp => cmp,
}
}
},
}
}
#[inline]
fn lt(&self, other: &VarLengthValue) -> bool {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0_0),
&(*__self_1_0),
),
::core::cmp::Ordering::Greater,
) == ::core::cmp::Ordering::Less
}
},
}
}
#[inline]
fn le(&self, other: &VarLengthValue) -> bool {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0_0),
&(*__self_1_0),
),
::core::cmp::Ordering::Greater,
) != ::core::cmp::Ordering::Greater
}
},
}
}
#[inline]
fn gt(&self, other: &VarLengthValue) -> bool {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0_0),
&(*__self_1_0),
),
::core::cmp::Ordering::Less,
) == ::core::cmp::Ordering::Greater
}
},
}
}
#[inline]
fn ge(&self, other: &VarLengthValue) -> bool {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => {
::core::option::Option::unwrap_or(
::core::cmp::PartialOrd::partial_cmp(
&(*__self_0_0),
&(*__self_1_0),
),
::core::cmp::Ordering::Less,
) != ::core::cmp::Ordering::Less
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Ord for VarLengthValue {
#[inline]
fn cmp(&self, other: &VarLengthValue) -> ::core::cmp::Ordering {
match *other {
VarLengthValue(ref __self_1_0) => match *self {
VarLengthValue(ref __self_0_0) => {
match ::core::cmp::Ord::cmp(&(*__self_0_0), &(*__self_1_0)) {
::core::cmp::Ordering::Equal => ::core::cmp::Ordering::Equal,
cmp => cmp,
}
}
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_VarLengthValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for VarLengthValue {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<VarLengthValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = VarLengthValue;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct VarLengthValue",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: u32 = match <u32 as _serde::Deserialize>::deserialize(__e)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(VarLengthValue(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<u32>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct VarLengthValue with 1 element",
));
}
};
_serde::export::Ok(VarLengthValue(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"VarLengthValue",
__Visitor {
marker: _serde::export::PhantomData::<VarLengthValue>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_VarLengthValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for VarLengthValue {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(
__serializer,
"VarLengthValue",
&self.0,
)
}
}
};
#[allow(warnings)]
impl ::binread::BinRead for VarLengthValue {
type Args = ();
fn read_options<R: ::binread::io::Read + ::binread::io::Seek>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<Self> {
let () = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = __binread_generated_var_options;
let mut self_0: u32 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((read(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(Self(self_0))
}
fn after_parse<R: ::binread::io::Read + ::binread::io::Seek>(
&mut self,
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<()> {
Ok(())
}
}
fn read<R: Read + Seek>(reader: &mut R, _: &ReadOptions, _: ()) -> BinResult<u32> {
{
::std::io::_print(::core::fmt::Arguments::new_v1(
&["Current location: 0x", "\n"],
&match (&reader.seek(SeekFrom::Current(0))?,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::LowerHex::fmt,
)],
},
));
};
let mut value = 0u32;
let max_bytes = 4;
for _ in 0..max_bytes {
let byte = u8::read(reader)? as u32;
value |= byte & 0x7f;
if (byte & 0x80) != 0 {
value <<= 7;
} else {
break;
}
}
Ok(VarLengthValue::bounded(value))
}
impl From<u32> for VarLengthValue {
fn from(value: u32) -> VarLengthValue {
Self(Self::bounded(value))
}
}
impl Into<u32> for VarLengthValue {
fn into(self) -> u32 {
self.0
}
}
impl Bounded<u32> for VarLengthValue {
const MIN: u32 = 0;
const MAX: u32 = 0x0fff_ffff;
}
}
pub mod event {
mod meta_event {
use crate::midi::VarLengthValue;
use binread::BinRead;
use serde::{Deserialize, Serialize};
pub struct MetaEvent {
meta_type: u8,
length: VarLengthValue,
#[br(args(meta_type, length))]
pub variant: MetaEventType,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for MetaEvent {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
MetaEvent {
meta_type: ref __self_0_0,
length: ref __self_0_1,
variant: ref __self_0_2,
} => {
let mut debug_trait_builder = f.debug_struct("MetaEvent");
let _ = debug_trait_builder.field("meta_type", &&(*__self_0_0));
let _ = debug_trait_builder.field("length", &&(*__self_0_1));
let _ = debug_trait_builder.field("variant", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_MetaEvent: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for MetaEvent {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"meta_type" => _serde::export::Ok(__Field::__field0),
"length" => _serde::export::Ok(__Field::__field1),
"variant" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"meta_type" => _serde::export::Ok(__Field::__field0),
b"length" => _serde::export::Ok(__Field::__field1),
b"variant" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MetaEvent>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MetaEvent;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct MetaEvent",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<u8>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct MetaEvent with 3 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
VarLengthValue,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct MetaEvent with 3 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
MetaEventType,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct MetaEvent with 3 elements",
),
);
}
};
_serde::export::Ok(MetaEvent {
meta_type: __field0,
length: __field1,
variant: __field2,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> = _serde::export::None;
let mut __field1: _serde::export::Option<VarLengthValue> =
_serde::export::None;
let mut __field2: _serde::export::Option<MetaEventType> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "meta_type" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u8>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "length" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
VarLengthValue,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "variant" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
MetaEventType,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("meta_type") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("length") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("variant") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MetaEvent {
meta_type: __field0,
length: __field1,
variant: __field2,
})
}
}
const FIELDS: &'static [&'static str] = &["meta_type", "length", "variant"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"MetaEvent",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MetaEvent>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_MetaEvent: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for MetaEvent {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"MetaEvent",
false as usize + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"meta_type",
&self.meta_type,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"length",
&self.length,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"variant",
&self.variant,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(warnings)]
impl ::binread::BinRead for MetaEvent {
type Args = ();
fn read_options<R: ::binread::io::Read + ::binread::io::Seek>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<Self> {
let () = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __meta_type_binwrite_generated_args = ();
let __meta_type_binwrite_generated_options = __binread_generated_var_options;
let mut meta_type: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__meta_type_binwrite_generated_options,
__meta_type_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__meta_type_binwrite_generated_options,
__meta_type_binwrite_generated_args,
)?);
__binread__temp
};
let __length_binwrite_generated_args = ();
let __length_binwrite_generated_options = __binread_generated_var_options;
let mut length: VarLengthValue = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__length_binwrite_generated_options,
__length_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__length_binwrite_generated_options,
__length_binwrite_generated_args,
)?);
__binread__temp
};
let __variant_binwrite_generated_args = ((|| meta_type)(), (|| length)());
let __variant_binwrite_generated_options = __binread_generated_var_options;
let mut variant: MetaEventType = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__variant_binwrite_generated_options,
__variant_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__variant_binwrite_generated_options,
__variant_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut meta_type,
__binread_generated_var_reader,
__meta_type_binwrite_generated_options,
__meta_type_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut length,
__binread_generated_var_reader,
__length_binwrite_generated_options,
__length_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut variant,
__binread_generated_var_reader,
__variant_binwrite_generated_options,
__variant_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(Self {
meta_type,
length,
variant,
})
}
fn after_parse<R: ::binread::io::Read + ::binread::io::Seek>(
&mut self,
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<()> {
Ok(())
}
}
# [ br ( import ( ty : u8 , len : VarLengthValue ) ) ]
pub enum MetaEventType {
# [ br ( assert ( ty == 0 ) ) ]
SequenceNumber(# [ br ( if ( len . 0 == 2 ) ) ] Option<u16>),
# [ br ( assert ( ty == 1 ) ) ]
Text(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 2 ) ) ]
Copyright(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 3 ) ) ]
TrackName(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 4 ) ) ]
Instrument(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 5 ) ) ]
Lyric(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 6 ) ) ]
Marker(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 7 ) ) ]
CuePoint(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 8 ) ) ]
ProgramName(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 9 ) ) ]
DeviceName(
# [ br ( count = len . 0 ) ]
# [ br ( map = | v : Vec < u8 > | String :: from_utf8_lossy ( & v ) . to_string ( ) ) ]
String,
),
# [ br ( assert ( ty == 0x20 ) ) ]
MidiChannelPrefix(u8),
# [ br ( assert ( ty == 0x21 ) ) ]
MidiPort(u8),
# [ br ( assert ( ty == 0x2f ) ) ]
EndOfTrack,
# [ br ( assert ( ty == 0x51 ) ) ]
Tempo {
ms_per_beat: u32,
},
# [ br ( assert ( ty == 0x54 ) ) ]
SMPTEOffset {
hours: u8,
minutes: u8,
seconds: u8,
fr: u8,
ff: u8,
},
# [ br ( assert ( ty == 0x58 ) ) ]
TimeSignature {
numerator: u8,
denominator: u8,
clocks_per_metronome: u8,
something: u8,
},
# [ br ( assert ( ty == 0x59 ) ) ]
KeySignature {
sf: i8,
mi: u8,
},
Unsupported(# [ br ( count = len . 0 ) ] Vec<u8>),
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for MetaEventType {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&MetaEventType::SequenceNumber(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("SequenceNumber");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::Text(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Text");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::Copyright(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Copyright");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::TrackName(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("TrackName");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::Instrument(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Instrument");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::Lyric(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Lyric");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::Marker(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Marker");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::CuePoint(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("CuePoint");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::ProgramName(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("ProgramName");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::DeviceName(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("DeviceName");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::MidiChannelPrefix(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("MidiChannelPrefix");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::MidiPort(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("MidiPort");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::EndOfTrack,) => {
let mut debug_trait_builder = f.debug_tuple("EndOfTrack");
debug_trait_builder.finish()
}
(&MetaEventType::Tempo {
ms_per_beat: ref __self_0,
},) => {
let mut debug_trait_builder = f.debug_struct("Tempo");
let _ = debug_trait_builder.field("ms_per_beat", &&(*__self_0));
debug_trait_builder.finish()
}
(&MetaEventType::SMPTEOffset {
hours: ref __self_0,
minutes: ref __self_1,
seconds: ref __self_2,
fr: ref __self_3,
ff: ref __self_4,
},) => {
let mut debug_trait_builder = f.debug_struct("SMPTEOffset");
let _ = debug_trait_builder.field("hours", &&(*__self_0));
let _ = debug_trait_builder.field("minutes", &&(*__self_1));
let _ = debug_trait_builder.field("seconds", &&(*__self_2));
let _ = debug_trait_builder.field("fr", &&(*__self_3));
let _ = debug_trait_builder.field("ff", &&(*__self_4));
debug_trait_builder.finish()
}
(&MetaEventType::TimeSignature {
numerator: ref __self_0,
denominator: ref __self_1,
clocks_per_metronome: ref __self_2,
something: ref __self_3,
},) => {
let mut debug_trait_builder = f.debug_struct("TimeSignature");
let _ = debug_trait_builder.field("numerator", &&(*__self_0));
let _ = debug_trait_builder.field("denominator", &&(*__self_1));
let _ =
debug_trait_builder.field("clocks_per_metronome", &&(*__self_2));
let _ = debug_trait_builder.field("something", &&(*__self_3));
debug_trait_builder.finish()
}
(&MetaEventType::KeySignature {
sf: ref __self_0,
mi: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("KeySignature");
let _ = debug_trait_builder.field("sf", &&(*__self_0));
let _ = debug_trait_builder.field("mi", &&(*__self_1));
debug_trait_builder.finish()
}
(&MetaEventType::Unsupported(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Unsupported");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_MetaEventType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for MetaEventType {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__field7,
__field8,
__field9,
__field10,
__field11,
__field12,
__field13,
__field14,
__field15,
__field16,
__field17,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"variant identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
7u64 => _serde::export::Ok(__Field::__field7),
8u64 => _serde::export::Ok(__Field::__field8),
9u64 => _serde::export::Ok(__Field::__field9),
10u64 => _serde::export::Ok(__Field::__field10),
11u64 => _serde::export::Ok(__Field::__field11),
12u64 => _serde::export::Ok(__Field::__field12),
13u64 => _serde::export::Ok(__Field::__field13),
14u64 => _serde::export::Ok(__Field::__field14),
15u64 => _serde::export::Ok(__Field::__field15),
16u64 => _serde::export::Ok(__Field::__field16),
17u64 => _serde::export::Ok(__Field::__field17),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 18",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"SequenceNumber" => _serde::export::Ok(__Field::__field0),
"Text" => _serde::export::Ok(__Field::__field1),
"Copyright" => _serde::export::Ok(__Field::__field2),
"TrackName" => _serde::export::Ok(__Field::__field3),
"Instrument" => _serde::export::Ok(__Field::__field4),
"Lyric" => _serde::export::Ok(__Field::__field5),
"Marker" => _serde::export::Ok(__Field::__field6),
"CuePoint" => _serde::export::Ok(__Field::__field7),
"ProgramName" => _serde::export::Ok(__Field::__field8),
"DeviceName" => _serde::export::Ok(__Field::__field9),
"MidiChannelPrefix" => _serde::export::Ok(__Field::__field10),
"MidiPort" => _serde::export::Ok(__Field::__field11),
"EndOfTrack" => _serde::export::Ok(__Field::__field12),
"Tempo" => _serde::export::Ok(__Field::__field13),
"SMPTEOffset" => _serde::export::Ok(__Field::__field14),
"TimeSignature" => _serde::export::Ok(__Field::__field15),
"KeySignature" => _serde::export::Ok(__Field::__field16),
"Unsupported" => _serde::export::Ok(__Field::__field17),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"SequenceNumber" => _serde::export::Ok(__Field::__field0),
b"Text" => _serde::export::Ok(__Field::__field1),
b"Copyright" => _serde::export::Ok(__Field::__field2),
b"TrackName" => _serde::export::Ok(__Field::__field3),
b"Instrument" => _serde::export::Ok(__Field::__field4),
b"Lyric" => _serde::export::Ok(__Field::__field5),
b"Marker" => _serde::export::Ok(__Field::__field6),
b"CuePoint" => _serde::export::Ok(__Field::__field7),
b"ProgramName" => _serde::export::Ok(__Field::__field8),
b"DeviceName" => _serde::export::Ok(__Field::__field9),
b"MidiChannelPrefix" => _serde::export::Ok(__Field::__field10),
b"MidiPort" => _serde::export::Ok(__Field::__field11),
b"EndOfTrack" => _serde::export::Ok(__Field::__field12),
b"Tempo" => _serde::export::Ok(__Field::__field13),
b"SMPTEOffset" => _serde::export::Ok(__Field::__field14),
b"TimeSignature" => _serde::export::Ok(__Field::__field15),
b"KeySignature" => _serde::export::Ok(__Field::__field16),
b"Unsupported" => _serde::export::Ok(__Field::__field17),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MetaEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MetaEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"enum MetaEventType",
)
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<Option<u16>>(
__variant,
),
MetaEventType::SequenceNumber,
),
(__Field::__field1, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::Text,
),
(__Field::__field2, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::Copyright,
),
(__Field::__field3, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::TrackName,
),
(__Field::__field4, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::Instrument,
),
(__Field::__field5, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::Lyric,
),
(__Field::__field6, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::Marker,
),
(__Field::__field7, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::CuePoint,
),
(__Field::__field8, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::ProgramName,
),
(__Field::__field9, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<String>(
__variant,
),
MetaEventType::DeviceName,
),
(__Field::__field10, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<u8>(__variant),
MetaEventType::MidiChannelPrefix,
),
(__Field::__field11, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<u8>(__variant),
MetaEventType::MidiPort,
),
(__Field::__field12, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(MetaEventType::EndOfTrack)
}
(__Field::__field13, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 1",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"ms_per_beat" => {
_serde::export::Ok(__Field::__field0)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"ms_per_beat" => {
_serde::export::Ok(__Field::__field0)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MetaEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MetaEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MetaEventType::Tempo",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u32,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MetaEventType::Tempo with 1 element" ) ) ;
}
};
_serde::export::Ok(MetaEventType::Tempo {
ms_per_beat: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u32> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "ms_per_beat" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u32 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"ms_per_beat",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MetaEventType::Tempo {
ms_per_beat: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["ms_per_beat"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MetaEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field14, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 5",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"hours" => {
_serde::export::Ok(__Field::__field0)
}
"minutes" => {
_serde::export::Ok(__Field::__field1)
}
"seconds" => {
_serde::export::Ok(__Field::__field2)
}
"fr" => _serde::export::Ok(__Field::__field3),
"ff" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"hours" => {
_serde::export::Ok(__Field::__field0)
}
b"minutes" => {
_serde::export::Ok(__Field::__field1)
}
b"seconds" => {
_serde::export::Ok(__Field::__field2)
}
b"fr" => _serde::export::Ok(__Field::__field3),
b"ff" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MetaEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MetaEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MetaEventType::SMPTEOffset",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MetaEventType::SMPTEOffset with 5 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MetaEventType::SMPTEOffset with 5 elements" ) ) ;
}
};
let __field2 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 2usize , & "struct variant MetaEventType::SMPTEOffset with 5 elements" ) ) ;
}
};
let __field3 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 3usize , & "struct variant MetaEventType::SMPTEOffset with 5 elements" ) ) ;
}
};
let __field4 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 4usize , & "struct variant MetaEventType::SMPTEOffset with 5 elements" ) ) ;
}
};
_serde::export::Ok(MetaEventType::SMPTEOffset {
hours: __field0,
minutes: __field1,
seconds: __field2,
fr: __field3,
ff: __field4,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
let mut __field2: _serde::export::Option<u8> =
_serde::export::None;
let mut __field3: _serde::export::Option<u8> =
_serde::export::None;
let mut __field4: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "hours" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "minutes" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field2 => {
if _serde::export::Option::is_some(
&__field2,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "seconds" ) ) ;
}
__field2 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field3 => {
if _serde::export::Option::is_some(
&__field3,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "fr" ) ) ;
}
__field3 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field4 => {
if _serde::export::Option::is_some(
&__field4,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "ff" ) ) ;
}
__field4 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"hours",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"minutes",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field(
"seconds",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field(
"fr",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field(
"ff",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MetaEventType::SMPTEOffset {
hours: __field0,
minutes: __field1,
seconds: __field2,
fr: __field3,
ff: __field4,
})
}
}
const FIELDS: &'static [&'static str] =
&["hours", "minutes", "seconds", "fr", "ff"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MetaEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field15, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 4",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"numerator" => {
_serde::export::Ok(__Field::__field0)
}
"denominator" => {
_serde::export::Ok(__Field::__field1)
}
"clocks_per_metronome" => {
_serde::export::Ok(__Field::__field2)
}
"something" => {
_serde::export::Ok(__Field::__field3)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"numerator" => {
_serde::export::Ok(__Field::__field0)
}
b"denominator" => {
_serde::export::Ok(__Field::__field1)
}
b"clocks_per_metronome" => {
_serde::export::Ok(__Field::__field2)
}
b"something" => {
_serde::export::Ok(__Field::__field3)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MetaEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MetaEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MetaEventType::TimeSignature",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MetaEventType::TimeSignature with 4 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MetaEventType::TimeSignature with 4 elements" ) ) ;
}
};
let __field2 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 2usize , & "struct variant MetaEventType::TimeSignature with 4 elements" ) ) ;
}
};
let __field3 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 3usize , & "struct variant MetaEventType::TimeSignature with 4 elements" ) ) ;
}
};
_serde::export::Ok(MetaEventType::TimeSignature {
numerator: __field0,
denominator: __field1,
clocks_per_metronome: __field2,
something: __field3,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
let mut __field2: _serde::export::Option<u8> =
_serde::export::None;
let mut __field3: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "numerator" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "denominator" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field2 => {
if _serde::export::Option::is_some(
&__field2,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "clocks_per_metronome" ) ) ;
}
__field2 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field3 => {
if _serde::export::Option::is_some(
&__field3,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "something" ) ) ;
}
__field3 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"numerator",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"denominator",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field(
"clocks_per_metronome",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field(
"something",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MetaEventType::TimeSignature {
numerator: __field0,
denominator: __field1,
clocks_per_metronome: __field2,
something: __field3,
})
}
}
const FIELDS: &'static [&'static str] = &[
"numerator",
"denominator",
"clocks_per_metronome",
"something",
];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MetaEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field16, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"sf" => _serde::export::Ok(__Field::__field0),
"mi" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"sf" => _serde::export::Ok(__Field::__field0),
b"mi" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MetaEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MetaEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MetaEventType::KeySignature",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
i8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MetaEventType::KeySignature with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MetaEventType::KeySignature with 2 elements" ) ) ;
}
};
_serde::export::Ok(MetaEventType::KeySignature {
sf: __field0,
mi: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<i8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "sf" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < i8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "mi" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"sf",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"mi",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MetaEventType::KeySignature {
sf: __field0,
mi: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["sf", "mi"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MetaEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field17, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<Vec<u8>>(
__variant,
),
MetaEventType::Unsupported,
),
}
}
}
const VARIANTS: &'static [&'static str] = &[
"SequenceNumber",
"Text",
"Copyright",
"TrackName",
"Instrument",
"Lyric",
"Marker",
"CuePoint",
"ProgramName",
"DeviceName",
"MidiChannelPrefix",
"MidiPort",
"EndOfTrack",
"Tempo",
"SMPTEOffset",
"TimeSignature",
"KeySignature",
"Unsupported",
];
_serde::Deserializer::deserialize_enum(
__deserializer,
"MetaEventType",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<MetaEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_MetaEventType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for MetaEventType {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
MetaEventType::SequenceNumber(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
0u32,
"SequenceNumber",
__field0,
)
}
MetaEventType::Text(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
1u32,
"Text",
__field0,
)
}
MetaEventType::Copyright(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
2u32,
"Copyright",
__field0,
)
}
MetaEventType::TrackName(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
3u32,
"TrackName",
__field0,
)
}
MetaEventType::Instrument(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
4u32,
"Instrument",
__field0,
)
}
MetaEventType::Lyric(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
5u32,
"Lyric",
__field0,
)
}
MetaEventType::Marker(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
6u32,
"Marker",
__field0,
)
}
MetaEventType::CuePoint(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
7u32,
"CuePoint",
__field0,
)
}
MetaEventType::ProgramName(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
8u32,
"ProgramName",
__field0,
)
}
MetaEventType::DeviceName(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
9u32,
"DeviceName",
__field0,
)
}
MetaEventType::MidiChannelPrefix(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
10u32,
"MidiChannelPrefix",
__field0,
)
}
MetaEventType::MidiPort(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
11u32,
"MidiPort",
__field0,
)
}
MetaEventType::EndOfTrack => {
_serde::Serializer::serialize_unit_variant(
__serializer,
"MetaEventType",
12u32,
"EndOfTrack",
)
}
MetaEventType::Tempo { ref ms_per_beat } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MetaEventType",
13u32,
"Tempo",
0 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"ms_per_beat",
ms_per_beat,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MetaEventType::SMPTEOffset {
ref hours,
ref minutes,
ref seconds,
ref fr,
ref ff,
} => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MetaEventType",
14u32,
"SMPTEOffset",
0 + 1 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"hours",
hours,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"minutes",
minutes,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"seconds",
seconds,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"fr",
fr,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"ff",
ff,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MetaEventType::TimeSignature {
ref numerator,
ref denominator,
ref clocks_per_metronome,
ref something,
} => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MetaEventType",
15u32,
"TimeSignature",
0 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"numerator",
numerator,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"denominator",
denominator,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"clocks_per_metronome",
clocks_per_metronome,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"something",
something,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MetaEventType::KeySignature { ref sf, ref mi } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MetaEventType",
16u32,
"KeySignature",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"sf",
sf,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"mi",
mi,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MetaEventType::Unsupported(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"MetaEventType",
17u32,
"Unsupported",
__field0,
)
}
}
}
}
};
#[allow(warnings)]
impl ::binread::BinRead for MetaEventType {
type Args = (u8, VarLengthValue);
fn read_options<R: ::binread::io::Read + ::binread::io::Seek>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<Self> {
let mut __binread_generated_error_basket: Vec<(
&'static str,
::binread::Error,
)> = ::alloc::vec::Vec::new();
let __binread_generated_pos_before_variant = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
fn __binread_generated_parse_enum_MetaEventType_variant_SequenceNumber<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = __binread_generated_var_options;
let __self_0_binwrite_generated_cond_evaluated: bool = len.0 == 2;
let mut self_0: Option<u16> =
if (__self_0_binwrite_generated_cond_evaluated) {
let __binread__temp = Some(::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
} else {
None
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
if let Some(self_0) = self_0.as_mut() {
::binread::BinRead::after_parse(
self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::SequenceNumber(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_Text<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Text(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_Copyright<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Copyright(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_TrackName<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::TrackName(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_Instrument<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Instrument(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_Lyric<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Lyric(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_Marker<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Marker(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_CuePoint<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::CuePoint(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_ProgramName<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::ProgramName(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_DeviceName<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: String = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
(|v: Vec<u8>| String::from_utf8_lossy(&v).to_string())(
(::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?,
),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::error::nop5(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::DeviceName(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_MidiChannelPrefix<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = __binread_generated_var_options;
let mut self_0: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::MidiChannelPrefix(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_MidiPort<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = __binread_generated_var_options;
let mut self_0: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::MidiPort(self_0))
}
fn __binread_generated_parse_enum_MetaEventType_variant_EndOfTrack<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::EndOfTrack)
}
fn __binread_generated_parse_enum_MetaEventType_variant_Tempo<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __ms_per_beat_binwrite_generated_args = ();
let __ms_per_beat_binwrite_generated_options =
__binread_generated_var_options;
let mut ms_per_beat: u32 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__ms_per_beat_binwrite_generated_options,
__ms_per_beat_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__ms_per_beat_binwrite_generated_options,
__ms_per_beat_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut ms_per_beat,
__binread_generated_var_reader,
__ms_per_beat_binwrite_generated_options,
__ms_per_beat_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Tempo { ms_per_beat })
}
fn __binread_generated_parse_enum_MetaEventType_variant_SMPTEOffset<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __hours_binwrite_generated_args = ();
let __hours_binwrite_generated_options = __binread_generated_var_options;
let mut hours: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__hours_binwrite_generated_options,
__hours_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__hours_binwrite_generated_options,
__hours_binwrite_generated_args,
)?);
__binread__temp
};
let __minutes_binwrite_generated_args = ();
let __minutes_binwrite_generated_options = __binread_generated_var_options;
let mut minutes: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__minutes_binwrite_generated_options,
__minutes_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__minutes_binwrite_generated_options,
__minutes_binwrite_generated_args,
)?);
__binread__temp
};
let __seconds_binwrite_generated_args = ();
let __seconds_binwrite_generated_options = __binread_generated_var_options;
let mut seconds: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__seconds_binwrite_generated_options,
__seconds_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__seconds_binwrite_generated_options,
__seconds_binwrite_generated_args,
)?);
__binread__temp
};
let __fr_binwrite_generated_args = ();
let __fr_binwrite_generated_options = __binread_generated_var_options;
let mut fr: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__fr_binwrite_generated_options,
__fr_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__fr_binwrite_generated_options,
__fr_binwrite_generated_args,
)?);
__binread__temp
};
let __ff_binwrite_generated_args = ();
let __ff_binwrite_generated_options = __binread_generated_var_options;
let mut ff: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__ff_binwrite_generated_options,
__ff_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__ff_binwrite_generated_options,
__ff_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut hours,
__binread_generated_var_reader,
__hours_binwrite_generated_options,
__hours_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut minutes,
__binread_generated_var_reader,
__minutes_binwrite_generated_options,
__minutes_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut seconds,
__binread_generated_var_reader,
__seconds_binwrite_generated_options,
__seconds_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut fr,
__binread_generated_var_reader,
__fr_binwrite_generated_options,
__fr_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut ff,
__binread_generated_var_reader,
__ff_binwrite_generated_options,
__ff_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::SMPTEOffset {
hours,
minutes,
seconds,
fr,
ff,
})
}
fn __binread_generated_parse_enum_MetaEventType_variant_TimeSignature<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __numerator_binwrite_generated_args = ();
let __numerator_binwrite_generated_options =
__binread_generated_var_options;
let mut numerator: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__numerator_binwrite_generated_options,
__numerator_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__numerator_binwrite_generated_options,
__numerator_binwrite_generated_args,
)?);
__binread__temp
};
let __denominator_binwrite_generated_args = ();
let __denominator_binwrite_generated_options =
__binread_generated_var_options;
let mut denominator: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__denominator_binwrite_generated_options,
__denominator_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__denominator_binwrite_generated_options,
__denominator_binwrite_generated_args,
)?);
__binread__temp
};
let __clocks_per_metronome_binwrite_generated_args = ();
let __clocks_per_metronome_binwrite_generated_options =
__binread_generated_var_options;
let mut clocks_per_metronome: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__clocks_per_metronome_binwrite_generated_options,
__clocks_per_metronome_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__clocks_per_metronome_binwrite_generated_options,
__clocks_per_metronome_binwrite_generated_args,
)?);
__binread__temp
};
let __something_binwrite_generated_args = ();
let __something_binwrite_generated_options =
__binread_generated_var_options;
let mut something: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__something_binwrite_generated_options,
__something_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__something_binwrite_generated_options,
__something_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut numerator,
__binread_generated_var_reader,
__numerator_binwrite_generated_options,
__numerator_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut denominator,
__binread_generated_var_reader,
__denominator_binwrite_generated_options,
__denominator_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut clocks_per_metronome,
__binread_generated_var_reader,
__clocks_per_metronome_binwrite_generated_options,
__clocks_per_metronome_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut something,
__binread_generated_var_reader,
__something_binwrite_generated_options,
__something_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::TimeSignature {
numerator,
denominator,
clocks_per_metronome,
something,
})
}
fn __binread_generated_parse_enum_MetaEventType_variant_KeySignature<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __sf_binwrite_generated_args = ();
let __sf_binwrite_generated_options = __binread_generated_var_options;
let mut sf: i8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__sf_binwrite_generated_options,
__sf_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__sf_binwrite_generated_options,
__sf_binwrite_generated_args,
)?);
__binread__temp
};
let __mi_binwrite_generated_args = ();
let __mi_binwrite_generated_options = __binread_generated_var_options;
let mut mi: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__mi_binwrite_generated_options,
__mi_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__mi_binwrite_generated_options,
__mi_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut sf,
__binread_generated_var_reader,
__sf_binwrite_generated_options,
__sf_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut mi,
__binread_generated_var_reader,
__mi_binwrite_generated_options,
__mi_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::KeySignature { sf, mi })
}
fn __binread_generated_parse_enum_MetaEventType_variant_Unsupported<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MetaEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MetaEventType> {
let (mut ty, mut len) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __self_0_binwrite_generated_args = ();
let __self_0_binwrite_generated_options = &{
let mut temp = __binread_generated_var_options.clone();
temp.count = Some((len.0) as usize);
temp
};
let mut self_0: Vec<u8> = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut self_0,
__binread_generated_var_reader,
__self_0_binwrite_generated_options,
__self_0_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MetaEventType::Unsupported(self_0))
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_SequenceNumber(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"SequenceNumber",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Text(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Text", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Copyright(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Copyright", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_TrackName(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("TrackName", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Instrument(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"Instrument",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Lyric(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Lyric", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Marker(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Marker", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_CuePoint(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("CuePoint", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_ProgramName(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"ProgramName",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_DeviceName(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"DeviceName",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_MidiChannelPrefix(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"MidiChannelPrefix",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_MidiPort(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("MidiPort", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_EndOfTrack(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"EndOfTrack",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Tempo(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Tempo", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_SMPTEOffset(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"SMPTEOffset",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_TimeSignature(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"TimeSignature",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_KeySignature(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"KeySignature",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MetaEventType_variant_Unsupported(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"Unsupported",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
Err(::binread::Error::EnumErrors {
pos: __binread_generated_pos_before_variant as usize,
variant_errors: __binread_generated_error_basket,
})
}
fn after_parse<R: ::binread::io::Read + ::binread::io::Seek>(
&mut self,
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<()> {
Ok(())
}
}
}
mod midi_event {
use binread::io::{Read, Seek};
use binread::{BinRead, BinResult, ReadOptions};
use serde::{Deserialize, Serialize};
pub struct MidiEvent {
channel: u8,
event_type: MidiEventType,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for MidiEvent {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
MidiEvent {
channel: ref __self_0_0,
event_type: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("MidiEvent");
let _ = debug_trait_builder.field("channel", &&(*__self_0_0));
let _ = debug_trait_builder.field("event_type", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_MidiEvent: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for MidiEvent {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"channel" => _serde::export::Ok(__Field::__field0),
"event_type" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"channel" => _serde::export::Ok(__Field::__field0),
b"event_type" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEvent>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEvent;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct MidiEvent",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<u8>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct MidiEvent with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
MidiEventType,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct MidiEvent with 2 elements",
),
);
}
};
_serde::export::Ok(MidiEvent {
channel: __field0,
event_type: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> = _serde::export::None;
let mut __field1: _serde::export::Option<MidiEventType> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "channel" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u8>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "event_type" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
MidiEventType,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("channel") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("event_type") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEvent {
channel: __field0,
event_type: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["channel", "event_type"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"MidiEvent",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEvent>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_MidiEvent: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for MidiEvent {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"MidiEvent",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"channel",
&self.channel,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"event_type",
&self.event_type,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
# [ br ( import ( event_num : u8 ) ) ]
pub enum MidiEventType {
# [ br ( assert ( event_num == 0x8 ) ) ]
NoteOff { note: u8, velocity: u8 },
# [ br ( assert ( event_num == 0x9 ) ) ]
NoteOn { note: u8, velocity: u8 },
# [ br ( assert ( event_num == 0xa ) ) ]
NotePressure { note: u8, pressure: u8 },
# [ br ( assert ( event_num == 0xb ) ) ]
Controller { controller: u8, value: u8 },
# [ br ( assert ( event_num == 0xc ) ) ]
Program { program: u8 },
# [ br ( assert ( event_num == 0xd ) ) ]
Pressure { pressure: u8 },
# [ br ( assert ( event_num == 0xe ) ) ]
PitchBend { lsb: u8, msb: u8 },
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for MidiEventType {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&MidiEventType::NoteOff {
note: ref __self_0,
velocity: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("NoteOff");
let _ = debug_trait_builder.field("note", &&(*__self_0));
let _ = debug_trait_builder.field("velocity", &&(*__self_1));
debug_trait_builder.finish()
}
(&MidiEventType::NoteOn {
note: ref __self_0,
velocity: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("NoteOn");
let _ = debug_trait_builder.field("note", &&(*__self_0));
let _ = debug_trait_builder.field("velocity", &&(*__self_1));
debug_trait_builder.finish()
}
(&MidiEventType::NotePressure {
note: ref __self_0,
pressure: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("NotePressure");
let _ = debug_trait_builder.field("note", &&(*__self_0));
let _ = debug_trait_builder.field("pressure", &&(*__self_1));
debug_trait_builder.finish()
}
(&MidiEventType::Controller {
controller: ref __self_0,
value: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("Controller");
let _ = debug_trait_builder.field("controller", &&(*__self_0));
let _ = debug_trait_builder.field("value", &&(*__self_1));
debug_trait_builder.finish()
}
(&MidiEventType::Program {
program: ref __self_0,
},) => {
let mut debug_trait_builder = f.debug_struct("Program");
let _ = debug_trait_builder.field("program", &&(*__self_0));
debug_trait_builder.finish()
}
(&MidiEventType::Pressure {
pressure: ref __self_0,
},) => {
let mut debug_trait_builder = f.debug_struct("Pressure");
let _ = debug_trait_builder.field("pressure", &&(*__self_0));
debug_trait_builder.finish()
}
(&MidiEventType::PitchBend {
lsb: ref __self_0,
msb: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("PitchBend");
let _ = debug_trait_builder.field("lsb", &&(*__self_0));
let _ = debug_trait_builder.field("msb", &&(*__self_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_MidiEventType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for MidiEventType {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"variant identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 7",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"NoteOff" => _serde::export::Ok(__Field::__field0),
"NoteOn" => _serde::export::Ok(__Field::__field1),
"NotePressure" => _serde::export::Ok(__Field::__field2),
"Controller" => _serde::export::Ok(__Field::__field3),
"Program" => _serde::export::Ok(__Field::__field4),
"Pressure" => _serde::export::Ok(__Field::__field5),
"PitchBend" => _serde::export::Ok(__Field::__field6),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"NoteOff" => _serde::export::Ok(__Field::__field0),
b"NoteOn" => _serde::export::Ok(__Field::__field1),
b"NotePressure" => _serde::export::Ok(__Field::__field2),
b"Controller" => _serde::export::Ok(__Field::__field3),
b"Program" => _serde::export::Ok(__Field::__field4),
b"Pressure" => _serde::export::Ok(__Field::__field5),
b"PitchBend" => _serde::export::Ok(__Field::__field6),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"enum MidiEventType",
)
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"note" => _serde::export::Ok(__Field::__field0),
"velocity" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"note" => {
_serde::export::Ok(__Field::__field0)
}
b"velocity" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::NoteOff",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::NoteOff with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MidiEventType::NoteOff with 2 elements" ) ) ;
}
};
_serde::export::Ok(MidiEventType::NoteOff {
note: __field0,
velocity: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "note" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "velocity" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"note",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"velocity",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::NoteOff {
note: __field0,
velocity: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["note", "velocity"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field1, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"note" => _serde::export::Ok(__Field::__field0),
"velocity" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"note" => {
_serde::export::Ok(__Field::__field0)
}
b"velocity" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::NoteOn",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::NoteOn with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MidiEventType::NoteOn with 2 elements" ) ) ;
}
};
_serde::export::Ok(MidiEventType::NoteOn {
note: __field0,
velocity: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "note" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "velocity" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"note",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"velocity",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::NoteOn {
note: __field0,
velocity: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["note", "velocity"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field2, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"note" => _serde::export::Ok(__Field::__field0),
"pressure" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"note" => {
_serde::export::Ok(__Field::__field0)
}
b"pressure" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::NotePressure",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::NotePressure with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MidiEventType::NotePressure with 2 elements" ) ) ;
}
};
_serde::export::Ok(MidiEventType::NotePressure {
note: __field0,
pressure: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "note" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "pressure" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"note",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"pressure",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::NotePressure {
note: __field0,
pressure: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["note", "pressure"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field3, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"controller" => {
_serde::export::Ok(__Field::__field0)
}
"value" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"controller" => {
_serde::export::Ok(__Field::__field0)
}
b"value" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::Controller",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::Controller with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MidiEventType::Controller with 2 elements" ) ) ;
}
};
_serde::export::Ok(MidiEventType::Controller {
controller: __field0,
value: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "controller" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "value" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"controller",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"value",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::Controller {
controller: __field0,
value: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["controller", "value"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field4, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 1",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"program" => {
_serde::export::Ok(__Field::__field0)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"program" => {
_serde::export::Ok(__Field::__field0)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::Program",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::Program with 1 element" ) ) ;
}
};
_serde::export::Ok(MidiEventType::Program {
program: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "program" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"program",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::Program {
program: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["program"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field5, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 1",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"pressure" => {
_serde::export::Ok(__Field::__field0)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"pressure" => {
_serde::export::Ok(__Field::__field0)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::Pressure",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::Pressure with 1 element" ) ) ;
}
};
_serde::export::Ok(MidiEventType::Pressure {
pressure: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "pressure" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"pressure",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::Pressure {
pressure: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["pressure"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
(__Field::__field6, __variant) => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"lsb" => _serde::export::Ok(__Field::__field0),
"msb" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"lsb" => _serde::export::Ok(__Field::__field0),
b"msb" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<MidiEventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = MidiEventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant MidiEventType::PitchBend",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant MidiEventType::PitchBend with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
u8,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant MidiEventType::PitchBend with 2 elements" ) ) ;
}
};
_serde::export::Ok(MidiEventType::PitchBend {
lsb: __field0,
msb: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u8> =
_serde::export::None;
let mut __field1: _serde::export::Option<u8> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "lsb" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
__Field::__field1 => {
if _serde::export::Option::is_some(
&__field1,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "msb" ) ) ;
}
__field1 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < u8 > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"lsb",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"msb",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(MidiEventType::PitchBend {
lsb: __field0,
msb: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["lsb", "msb"];
_serde::de::VariantAccess::struct_variant(
__variant,
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
}
}
}
const VARIANTS: &'static [&'static str] = &[
"NoteOff",
"NoteOn",
"NotePressure",
"Controller",
"Program",
"Pressure",
"PitchBend",
];
_serde::Deserializer::deserialize_enum(
__deserializer,
"MidiEventType",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<MidiEventType>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_MidiEventType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for MidiEventType {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
MidiEventType::NoteOff {
ref note,
ref velocity,
} => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
0u32,
"NoteOff",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"note",
note,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"velocity",
velocity,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MidiEventType::NoteOn {
ref note,
ref velocity,
} => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
1u32,
"NoteOn",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"note",
note,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"velocity",
velocity,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MidiEventType::NotePressure {
ref note,
ref pressure,
} => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
2u32,
"NotePressure",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"note",
note,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"pressure",
pressure,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MidiEventType::Controller {
ref controller,
ref value,
} => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
3u32,
"Controller",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"controller",
controller,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"value",
value,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MidiEventType::Program { ref program } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
4u32,
"Program",
0 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"program",
program,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MidiEventType::Pressure { ref pressure } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
5u32,
"Pressure",
0 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"pressure",
pressure,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
MidiEventType::PitchBend { ref lsb, ref msb } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct_variant(
__serializer,
"MidiEventType",
6u32,
"PitchBend",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"lsb",
lsb,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStructVariant::serialize_field(
&mut __serde_state,
"msb",
msb,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStructVariant::end(__serde_state)
}
}
}
}
};
#[allow(warnings)]
impl ::binread::BinRead for MidiEventType {
type Args = (u8,);
fn read_options<R: ::binread::io::Read + ::binread::io::Seek>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<Self> {
let mut __binread_generated_error_basket: Vec<(
&'static str,
::binread::Error,
)> = ::alloc::vec::Vec::new();
let __binread_generated_pos_before_variant = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
fn __binread_generated_parse_enum_MidiEventType_variant_NoteOff<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __note_binwrite_generated_args = ();
let __note_binwrite_generated_options = __binread_generated_var_options;
let mut note: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
)?);
__binread__temp
};
let __velocity_binwrite_generated_args = ();
let __velocity_binwrite_generated_options = __binread_generated_var_options;
let mut velocity: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__velocity_binwrite_generated_options,
__velocity_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__velocity_binwrite_generated_options,
__velocity_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut note,
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut velocity,
__binread_generated_var_reader,
__velocity_binwrite_generated_options,
__velocity_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::NoteOff { note, velocity })
}
fn __binread_generated_parse_enum_MidiEventType_variant_NoteOn<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __note_binwrite_generated_args = ();
let __note_binwrite_generated_options = __binread_generated_var_options;
let mut note: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
)?);
__binread__temp
};
let __velocity_binwrite_generated_args = ();
let __velocity_binwrite_generated_options = __binread_generated_var_options;
let mut velocity: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__velocity_binwrite_generated_options,
__velocity_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__velocity_binwrite_generated_options,
__velocity_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut note,
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut velocity,
__binread_generated_var_reader,
__velocity_binwrite_generated_options,
__velocity_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::NoteOn { note, velocity })
}
fn __binread_generated_parse_enum_MidiEventType_variant_NotePressure<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __note_binwrite_generated_args = ();
let __note_binwrite_generated_options = __binread_generated_var_options;
let mut note: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
)?);
__binread__temp
};
let __pressure_binwrite_generated_args = ();
let __pressure_binwrite_generated_options = __binread_generated_var_options;
let mut pressure: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__pressure_binwrite_generated_options,
__pressure_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__pressure_binwrite_generated_options,
__pressure_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut note,
__binread_generated_var_reader,
__note_binwrite_generated_options,
__note_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut pressure,
__binread_generated_var_reader,
__pressure_binwrite_generated_options,
__pressure_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::NotePressure { note, pressure })
}
fn __binread_generated_parse_enum_MidiEventType_variant_Controller<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __controller_binwrite_generated_args = ();
let __controller_binwrite_generated_options =
__binread_generated_var_options;
let mut controller: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__controller_binwrite_generated_options,
__controller_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__controller_binwrite_generated_options,
__controller_binwrite_generated_args,
)?);
__binread__temp
};
let __value_binwrite_generated_args = ();
let __value_binwrite_generated_options = __binread_generated_var_options;
let mut value: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__value_binwrite_generated_options,
__value_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__value_binwrite_generated_options,
__value_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut controller,
__binread_generated_var_reader,
__controller_binwrite_generated_options,
__controller_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut value,
__binread_generated_var_reader,
__value_binwrite_generated_options,
__value_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::Controller { controller, value })
}
fn __binread_generated_parse_enum_MidiEventType_variant_Program<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __program_binwrite_generated_args = ();
let __program_binwrite_generated_options = __binread_generated_var_options;
let mut program: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__program_binwrite_generated_options,
__program_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__program_binwrite_generated_options,
__program_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut program,
__binread_generated_var_reader,
__program_binwrite_generated_options,
__program_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::Program { program })
}
fn __binread_generated_parse_enum_MidiEventType_variant_Pressure<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __pressure_binwrite_generated_args = ();
let __pressure_binwrite_generated_options = __binread_generated_var_options;
let mut pressure: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__pressure_binwrite_generated_options,
__pressure_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__pressure_binwrite_generated_options,
__pressure_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut pressure,
__binread_generated_var_reader,
__pressure_binwrite_generated_options,
__pressure_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::Pressure { pressure })
}
fn __binread_generated_parse_enum_MidiEventType_variant_PitchBend<
R: ::binread::io::Read + ::binread::io::Seek,
>(
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments : < MidiEventType as :: binread :: BinRead > :: Args,
) -> ::binread::BinResult<MidiEventType> {
let (mut event_num,) = __binread_generated_var_arguments;
let __binread_generated_var_options = __binread_generated_var_options;
let __lsb_binwrite_generated_args = ();
let __lsb_binwrite_generated_options = __binread_generated_var_options;
let mut lsb: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__lsb_binwrite_generated_options,
__lsb_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__lsb_binwrite_generated_options,
__lsb_binwrite_generated_args,
)?);
__binread__temp
};
let __msb_binwrite_generated_args = ();
let __msb_binwrite_generated_options = __binread_generated_var_options;
let mut msb: u8 = {
let __binread__temp = (::binread::error::identity_after_parse(
::binread::error::nop5,
((::binread::BinRead::read_options(
__binread_generated_var_reader,
__msb_binwrite_generated_options,
__msb_binwrite_generated_args,
))?),
__binread_generated_var_reader,
__msb_binwrite_generated_options,
__msb_binwrite_generated_args,
)?);
__binread__temp
};
let __binread_generated_saved_position = ::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Current(0),
)?;
{
::binread::BinRead::after_parse(
&mut lsb,
__binread_generated_var_reader,
__lsb_binwrite_generated_options,
__lsb_binwrite_generated_args,
)?
};
{
::binread::BinRead::after_parse(
&mut msb,
__binread_generated_var_reader,
__msb_binwrite_generated_options,
__msb_binwrite_generated_args,
)?
};
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_saved_position),
)?;
Ok(MidiEventType::PitchBend { lsb, msb })
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_NoteOff(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("NoteOff", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_NoteOn(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("NoteOn", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_NotePressure(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"NotePressure",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_Controller(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket.push((
"Controller",
__binread_generated_last_attempt.err().unwrap(),
));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_Program(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Program", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_Pressure(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("Pressure", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
let __binread_generated_last_attempt =
__binread_generated_parse_enum_MidiEventType_variant_PitchBend(
__binread_generated_var_reader,
__binread_generated_var_options,
__binread_generated_var_arguments,
);
if __binread_generated_last_attempt.is_ok() {
return __binread_generated_last_attempt;
} else {
__binread_generated_error_basket
.push(("PitchBend", __binread_generated_last_attempt.err().unwrap()));
::binread::io::Seek::seek(
__binread_generated_var_reader,
::binread::io::SeekFrom::Start(__binread_generated_pos_before_variant),
)?;
}
Err(::binread::Error::EnumErrors {
pos: __binread_generated_pos_before_variant as usize,
variant_errors: __binread_generated_error_basket,
})
}
fn after_parse<R: ::binread::io::Read + ::binread::io::Seek>(
&mut self,
__binread_generated_var_reader: &mut R,
__binread_generated_var_options: &::binread::ReadOptions,
__binread_generated_var_arguments: Self::Args,
) -> ::binread::BinResult<()> {
Ok(())
}
}
impl BinRead for MidiEvent {
type Args = u8;
fn read_options<R: Read + Seek>(
reader: &mut R,
ro: &ReadOptions,
status: Self::Args,
) -> BinResult<Self> {
let event_num = status >> 4;
let channel = status & 0xf;
Ok(Self {
channel,
event_type: MidiEventType::read_options(reader, ro, (event_num,))?,
})
}
}
}
mod sysex_event {}
pub use meta_event::*;
pub use midi_event::*;
pub use sysex_event::*;
use super::VarLengthValue;
use binread::io::{Read, Seek, SeekFrom};
use binread::{BinRead, BinResult, ReadOptions};
use serde::{Deserialize, Serialize};
pub(crate) struct EventWithRet(pub Event, pub Option<u8>);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EventWithRet {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EventWithRet(ref __self_0_0, ref __self_0_1) => {
let mut debug_trait_builder = f.debug_tuple("EventWithRet");
let _ = debug_trait_builder.field(&&(*__self_0_0));
let _ = debug_trait_builder.field(&&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
/// A top-level event struct in a Track, containing a delta time and one of 3 event types
pub struct Event {
/// The number of Timing units since the last event
delta: VarLengthValue,
event_type: EventType,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Event {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Event {
delta: ref __self_0_0,
event_type: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("Event");
let _ = debug_trait_builder.field("delta", &&(*__self_0_0));
let _ = debug_trait_builder.field("event_type", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Event: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Event {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"delta" => _serde::export::Ok(__Field::__field0),
"event_type" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"delta" => _serde::export::Ok(__Field::__field0),
b"event_type" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Event>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Event;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct Event")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
VarLengthValue,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct Event with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
EventType,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct Event with 2 elements",
));
}
};
_serde::export::Ok(Event {
delta: __field0,
event_type: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<VarLengthValue> =
_serde::export::None;
let mut __field1: _serde::export::Option<EventType> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"delta",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<VarLengthValue>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"event_type",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<EventType>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("delta") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("event_type") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(Event {
delta: __field0,
event_type: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["delta", "event_type"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Event",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Event>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Event: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Event {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Event",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"delta",
&self.delta,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"event_type",
&self.event_type,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
pub(crate) struct EventTypeWithRet(pub EventType, pub Option<u8>);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EventTypeWithRet {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EventTypeWithRet(ref __self_0_0, ref __self_0_1) => {
let mut debug_trait_builder = f.debug_tuple("EventTypeWithRet");
let _ = debug_trait_builder.field(&&(*__self_0_0));
let _ = debug_trait_builder.field(&&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
pub enum EventType {
Midi(MidiEvent),
Meta(MetaEvent),
Unsupported(u8, Vec<u8>),
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EventType {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&EventType::Midi(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Midi");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&EventType::Meta(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("Meta");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&EventType::Unsupported(ref __self_0, ref __self_1),) => {
let mut debug_trait_builder = f.debug_tuple("Unsupported");
let _ = debug_trait_builder.field(&&(*__self_0));
let _ = debug_trait_builder.field(&&(*__self_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_EventType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for EventType {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"Midi" => _serde::export::Ok(__Field::__field0),
"Meta" => _serde::export::Ok(__Field::__field1),
"Unsupported" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"Midi" => _serde::export::Ok(__Field::__field0),
b"Meta" => _serde::export::Ok(__Field::__field1),
b"Unsupported" => _serde::export::Ok(__Field::__field2),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<EventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = EventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum EventType")
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<MidiEvent>(
__variant,
),
EventType::Midi,
),
(__Field::__field1, __variant) => _serde::export::Result::map(
_serde::de::VariantAccess::newtype_variant::<MetaEvent>(
__variant,
),
EventType::Meta,
),
(__Field::__field2, __variant) => {
struct __Visitor<'de> {
marker: _serde::export::PhantomData<EventType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = EventType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"tuple variant EventType::Unsupported",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<u8>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "tuple variant EventType::Unsupported with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
Vec<u8>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "tuple variant EventType::Unsupported with 2 elements" ) ) ;
}
};
_serde::export::Ok(EventType::Unsupported(
__field0, __field1,
))
}
}
_serde::de::VariantAccess::tuple_variant(
__variant,
2usize,
__Visitor {
marker: _serde::export::PhantomData::<EventType>,
lifetime: _serde::export::PhantomData,
},
)
}
}
}
}
const VARIANTS: &'static [&'static str] = &["Midi", "Meta", "Unsupported"];
_serde::Deserializer::deserialize_enum(
__deserializer,
"EventType",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<EventType>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_EventType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for EventType {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
EventType::Midi(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"EventType",
0u32,
"Midi",
__field0,
)
}
EventType::Meta(ref __field0) => {
_serde::Serializer::serialize_newtype_variant(
__serializer,
"EventType",
1u32,
"Meta",
__field0,
)
}
EventType::Unsupported(ref __field0, ref __field1) => {
let mut __serde_state =
match _serde::Serializer::serialize_tuple_variant(
__serializer,
"EventType",
2u32,
"Unsupported",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state,
__field0,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state,
__field1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeTupleVariant::end(__serde_state)
}
}
}
}
};
impl BinRead for EventWithRet {
type Args = Option<u8>;
fn read_options<R: Read + Seek>(
reader: &mut R,
ro: &ReadOptions,
running_status: Self::Args,
) -> BinResult<Self> {
let delta = VarLengthValue::read(reader)?;
let EventTypeWithRet(event_type, ret) =
EventTypeWithRet::read_options(reader, ro, running_status)?;
Ok(EventWithRet(Event { delta, event_type }, ret))
}
}
impl BinRead for EventTypeWithRet {
type Args = Option<u8>;
fn read_options<R: Read + Seek>(
reader: &mut R,
ro: &ReadOptions,
running_status: Self::Args,
) -> BinResult<Self> {
let mut next_event = u8::read(reader)?;
if next_event < 0x80 {
next_event =
running_status.expect("Event byte not found, and no running status is set");
reader.seek(SeekFrom::Current(-1))?;
}
match next_event {
0x00..=0x7f => {
::std::rt::begin_panic("internal error: entered unreachable code")
}
0x80..=0xef => {
let midi_event = MidiEvent::read_options(reader, ro, next_event)?;
Ok(EventTypeWithRet(
EventType::Midi(midi_event),
Some(next_event),
))
}
0xff => {
{
::std::io::_print(::core::fmt::Arguments::new_v1(
&["BEGIN READ META. Position = 0x", "\n"],
&match (&reader.seek(SeekFrom::Current(0))?,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::LowerHex::fmt,
)],
},
));
};
let meta_event = MetaEvent::read(reader)?;
{
::std::io::_print(::core::fmt::Arguments::new_v1(
&["END READ META. Position = 0x", "\n"],
&match (&reader.seek(SeekFrom::Current(0))?,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::LowerHex::fmt,
)],
},
));
};
Ok(EventTypeWithRet(
EventType::Meta(meta_event),
Some(next_event),
))
}
_ => {
let len = VarLengthValue::read(reader)?;
let mut bytes = ::alloc::vec::from_elem(0u8, len.0 as usize);
reader.read_exact(&mut bytes)?;
Ok(EventTypeWithRet(
EventType::Unsupported(next_event, bytes),
running_status,
))
}
}
}
}
}
pub use file::*;
pub use format::*;
pub use smpte_timecode::*;
pub use timing::*;
pub use track::*;
pub use var_length_value::*;
}
pub mod utils {
mod bounded {
pub trait Bounded<T>
where
T: Copy + PartialOrd,
{
const MIN: T;
const MAX: T;
fn bounded(value: T) -> T {
if value > Self::MAX {
Self::MAX
} else if value < Self::MIN {
Self::MIN
} else {
value
}
}
fn is_in_range(value: T) -> bool {
value <= Self::MAX || value >= Self::MIN
}
}
}
pub use bounded::*;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment