Refactoring

src/bin/copy.rs

@@ -1,8 +1,9 @@
 extern crate rimd;
 
-use rimd::{SMF,SMFError,SMFWriter};
+use rimd::{SMF,SMFWriter};
 use std::env::{args,Args};
 use std::path::Path;
+use std::convert::TryFrom;
 
 fn main() {
     let mut args: Args = args();
@@ -15,18 +16,13 @@ fn main() {
         Some(s) => s,
         None => { panic!("Need a destination path") },
     };
-    match SMF::from_file(&Path::new(&pathstr[..])) {
+    match SMF::try_from(Path::new(&pathstr[..])) {
         Ok(smf) => {
-            let writer = SMFWriter::from_smf(smf);
+            let writer = SMFWriter::from(smf);
             writer.write_to_file(&Path::new(&deststr[..])).unwrap();
         }
         Err(e) => {
-            match e {
-                SMFError::InvalidSMFFile(s) => {println!("{}",s);}
-                SMFError::Error(e) => {println!("io: {}",e);}
-                SMFError::MidiError(_) => {println!("Midi Error");}
-                SMFError::MetaError(_) => {println!("Meta Error");}
-            }
+            println!("{}",e)
         }
     }
 }

src/bin/test.rs

@@ -1,8 +1,9 @@
 extern crate rimd;
 
-use rimd::{SMF,SMFError};
+use rimd::{SMF};
 use std::env::{args,Args};
 use std::path::Path;
+use std::convert::TryFrom;
 
 fn main() {
     let mut args: Args = args();
@@ -12,11 +13,9 @@ fn main() {
         None => { panic!("Please pass a path to an SMF to test") },
     };
     println!("Reading: {}",pathstr);
-    match SMF::from_file(&Path::new(&pathstr[..])) {
+    match SMF::try_from(Path::new(&pathstr[..])) {
         Ok(smf) => {
-            println!("format: {}",smf.format);
-            println!("tracks: {}",smf.tracks.len());
-            println!("division: {}",smf.division);
+            println!("{}", smf);
             let mut tnum = 1;
             for track in smf.tracks.iter() {
                 let mut time: u64 = 0;
@@ -29,12 +28,7 @@ fn main() {
             }
         }
         Err(e) => {
-            match e {
-                SMFError::InvalidSMFFile(s) => {println!("{}",s);}
-                SMFError::Error(e) => {println!("io: {}",e);}
-                SMFError::MidiError(e) => {println!("Midi Error: {}",e);}
-                SMFError::MetaError(_) => {println!("Meta Error");}
-            }
+            println!("{}", e);
         }
     }
 }

src/builder.rs

@@ -8,19 +8,19 @@ use ::{SMF,Event,SMFFormat,MetaEvent,MidiMessage,Track,TrackEvent};
 /// This is useful for apps that want to store events internally
 /// with absolute times and then quickly build an SMF file for saving etc...
 pub struct AbsoluteEvent {
-    time: u64,
-    event: Event,
+    pub time: u64,
+    pub event: Event,
 }
 
 impl AbsoluteEvent {
-    pub fn new_midi(time: u64, midi: MidiMessage) -> AbsoluteEvent {
-        AbsoluteEvent {
+    pub fn new_midi(time: u64, midi: MidiMessage) -> Self {
+        Self {
             time: time,
             event: Event::Midi(midi),
         }
     }
-    pub fn new_meta(time: u64, meta: MetaEvent) -> AbsoluteEvent {
-        AbsoluteEvent {
+    pub fn new_meta(time: u64, meta: MetaEvent) -> Self {
+        Self {
             time: time,
             event: Event::Meta(meta),
         }
@@ -29,27 +29,13 @@ impl AbsoluteEvent {
     /// Return true if the event inside this AbsoluteEvent is a midi
     /// event, false if it's a meta event
     pub fn is_midi(&self) -> bool {
-        match self.event {
-            Event::Midi(_) => true,
-            Event::Meta(_) => false,
-        }
+        self.event.is_midi()
     }
 
     /// Return true if the event inside this AbsoluteEvent is a meta
     /// event, false if it's a midi event
     pub fn is_meta(&self) -> bool {
-        match self.event {
-            Event::Midi(_) => false,
-            Event::Meta(_) => true,
-        }
-    }
-
-    pub fn get_event(&self) -> &Event {
-        &self.event
-    }
-
-    pub fn get_time(&self) -> u64 {
-        self.time
+        self.event.is_meta()
     }
 }
 
@@ -187,14 +173,14 @@ pub struct SMFBuilder {
 
 impl SMFBuilder {
     /// Create a new SMFBuilder.  Initially the builder will have no tracks
-    pub fn new() -> SMFBuilder {
-        SMFBuilder {
+    pub fn new() -> Self {
+        Self {
             tracks: Vec::new(),
         }
     }
 
     /// Get the number of tracks currenly in the builder
-    pub fn num_tracks(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.tracks.len()
     }
 

src/lib.rs

@@ -117,6 +117,20 @@ impl Event {
             }
         }
     }
+
+    pub fn is_midi(&self) -> bool {
+        match self {
+            Event::Midi(_) => true,
+            Event::Meta(_) => false,
+        }
+    }
+
+    pub fn is_meta(&self) -> bool {
+        match self {
+            Event::Midi(_) => false,
+            Event::Meta(_) => true,
+        }
+    }
 }
 
 /// An event occuring in the track.
@@ -185,25 +199,25 @@ pub enum SMFError {
 }
 
 impl From<Error> for SMFError {
-    fn from(err: Error) -> SMFError {
+    fn from(err: Error) -> Self {
         SMFError::Error(err)
     }
 }
 
 impl From<MidiError> for SMFError {
-    fn from(err: MidiError) -> SMFError {
+    fn from(err: MidiError) -> Self {
         SMFError::MidiError(err)
     }
 }
 
 impl From<MetaError> for SMFError {
-    fn from(err: MetaError) -> SMFError {
+    fn from(err: MetaError) -> Self {
         SMFError::MetaError(err)
     }
 }
 
 impl From<FromUtf8Error> for SMFError {
-    fn from(_: FromUtf8Error) -> SMFError {
+    fn from(_: FromUtf8Error) -> Self {
         SMFError::InvalidSMFFile("Invalid UTF8 data in file")
     }
 }
@@ -255,21 +269,16 @@ pub struct SMF {
 
 
 impl SMF {
-    /// Read an SMF file at the given path
-    pub fn from_file(path: &Path) -> Result<SMF,SMFError> {
-        let mut file = try!(File::open(path));
-        SMFReader::read_smf(&mut file)
-    }
 
-    /// Read an SMF from the given reader
-    pub fn from_reader(reader: &mut dyn Read) -> Result<SMF,SMFError> {
-        SMFReader::read_smf(reader)
+    pub fn len(&self) -> usize {
+        self.tracks.len()
     }
+    /// Read an SMF file at the given path
 
     /// Convert a type 0 (single track) to type 1 (multi track) SMF
     /// Does nothing if the SMF is already in type 1
     /// Returns None if the SMF is in type 2 (multi song)
-    pub fn to_multi_track(&self) -> Option<SMF> {
+    pub fn to_multi_track(&self) -> Option<Self> {
         match self.format {
             SMFFormat::MultiTrack => Some(self.clone()),
             SMFFormat::MultiSong => None,
@@ -320,3 +329,24 @@ impl SMF {
     }
 }
 
+impl fmt::Display for SMF {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "format: {}, tracks: {}, division: {}", self.format, self.len(), self.division)
+    }
+}
+
+impl<'a> std::convert::TryFrom<&'a Path> for SMF {
+    type Error = SMFError;
+    fn try_from(path: &'a Path) -> Result<Self, Self::Error> {
+        let mut file = File::open(path)?;
+        SMFReader::read_smf(&mut file)
+    }
+}
+
+impl<'a> std::convert::TryFrom<&'a mut dyn Read> for SMF {
+    type Error = SMFError;
+    /// Read an SMF from the given reader
+    fn try_from(reader: &'a mut dyn Read) -> Result<Self, Self::Error> {
+        SMFReader::read_smf(reader)
+    }
+}