Struct ghakuf::reader::Reader

pub struct Reader<'a, R = File> { /* fields omitted */ }

ghakuf's SMF parser.

Examples

use ghakuf::messages::*;
use ghakuf::reader::*;
use std::path;

let path = path::Path::new("tests/test.mid");
let mut handler = HogeHandler {};
let mut reader = Reader::new(&mut handler, &path).unwrap();
let _ = reader.read();

struct HogeHandler {}
impl Handler for HogeHandler {
    fn header(&mut self, format: u16, track: u16, time_base: u16) {
        let _ = (format, track, time_base);
    }
    fn meta_event(&mut self, delta_time: u32, event: &MetaEvent, data: &Vec<u8>) {
        let _ = (delta_time, event, data);
    }
    fn midi_event(&mut self, delta_time: u32, event: &MidiEvent) {
        let _ = (delta_time, event);
    }
    fn sys_ex_event(&mut self, delta_time: u32, event: &SysExEvent, data: &Vec<u8>) {
        let _ = (delta_time, event, data);
    }
    fn track_change(&mut self) {}
}

Implementations

impl<'a> Reader<'a, File>

pub fn new(
    handler: &'a mut dyn Handler,
    path: &'a Path
) -> Result<Reader<'a, File>, ReadError<'a>>

Builds Reader with handler(observer) and SMF file path.

Examples

use ghakuf::reader::*;
use std::path;

let path = path::Path::new("tests/test.mid");
let mut handler = FugaHandler {};
let mut reader = Reader::new(&mut handler, &path);

struct FugaHandler {}
impl Handler for FugaHandler {}

impl<'a, R> Reader<'a, R> where
    R: Read + Seek, 

pub fn from_reader(
    handler: &'a mut dyn Handler,
    reader: R
) -> Result<Reader<'a, R>, ReadError<'a>>

Builds Reader with handler(observer) and a Read object.

Examples

use ghakuf::reader::*;
use std::path;
use std::io::Cursor;

let midi_file = include_bytes!("../tests/test.mid");
let midi_file = Cursor::new(&midi_file[..]);
 
let mut handler = FugaHandler {};
let mut reader = Reader::from_reader(&mut handler, midi_file);

struct FugaHandler {}
impl Handler for FugaHandler {}

pub fn push_handler(&mut self, handler: &'a mut dyn Handler)

Pushes Handler to Reader.

Examples

use ghakuf::reader::*;
use std::path;

let path = path::Path::new("tests/test.mid");
let mut fuga_handler = FugaHandler {};
let mut nyan_handler = NyanHandler {};
let mut reader = Reader::new(&mut fuga_handler, &path).unwrap();
reader.push_handler(&mut nyan_handler);

struct FugaHandler {}
impl Handler for FugaHandler {}

struct NyanHandler {}
impl Handler for NyanHandler {}

pub fn read(&mut self) -> Result<(), ReadError<'_>>

Parses SMF messages and fires(broadcasts) handlers.

Examples

use ghakuf::messages::*;
use ghakuf::reader::*;
use std::path;

let path = path::Path::new("tests/test.mid");
let mut handler = HogeHandler{};
let mut reader = Reader::new(&mut handler, &path).unwrap();
let _ = reader.read();

struct HogeHandler {}
impl Handler for HogeHandler {
    fn header(&mut self, format: u16, track: u16, time_base: u16) {
        let _ = (format, track, time_base);
    }
    fn meta_event(&mut self, delta_time: u32, event: &MetaEvent, data: &Vec<u8>) {
        let _ = (delta_time, event, data);
    }
    fn midi_event(&mut self, delta_time: u32, event: &MidiEvent) {
        let _ = (delta_time, event);
    }
    fn sys_ex_event(&mut self, delta_time: u32, event: &SysExEvent, data: &Vec<u8>) {
        let _ = (delta_time, event, data);
    }
    fn track_change(&mut self) {}
}