Fix no_std support

Make all feature combinations compile.

Implement `Debug` and `Hash` everywhere.

Expose `as_never` method on `NotSeekable`.

Author: kovaxis

CHANGELOG.md

@@ -21,6 +21,7 @@
 - Added a `PitchBend` newtype to manipulate pitch bend values.
 - Added a `live` module that allows parsing raw MIDI event bytes.
 - Added a `stream` module to support raw MIDI stream decoding.
+- All types now implement `Debug`, and all data types implement `Hash`.
 
 ## 0.4
 

src/event.rs

@@ -9,7 +9,7 @@ use crate::{
 /// Represents a parsed SMF track event.
 ///
 /// Consists of a delta time with respect to the previous event and the actual track event.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TrackEvent<'a> {
     /// How many MIDI ticks after the previous event should this event fire off.
     pub delta: u28,
@@ -59,7 +59,7 @@ impl<'a> TrackEvent<'a> {
 ///
 /// It notably does *not* include the timing of the event; the `TrackEvent` struct is responsible
 /// for this.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum TrackEventKind<'a> {
     /// A message associated to a MIDI channel carrying musical data.
     ///
@@ -196,7 +196,7 @@ impl<'a> TrackEventKind<'a> {
 /// If you wish to parse a MIDI message from a slice of raw MIDI bytes, use the
 /// [`LiveEvent::parse`](live/enum.LiveEvent.html#method.parse) method instead and ignore all
 /// variants except for [`LiveEvent::Midi`](live/enum.LiveEvent.html#variant.Midi).
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum MidiMessage {
     /// Stop playing a note.
     NoteOff {
@@ -352,7 +352,7 @@ impl MidiMessage {
 /// A value of `0x0000` indicates full bend downwards.
 /// A value of `0x2000` indicates no bend.
 /// A value of `0x3FFF` indicates full bend upwards.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct PitchBend(pub u14);
 impl PitchBend {
     /// The minimum value of `0x0000`, indicating full bend downwards.
@@ -405,7 +405,7 @@ impl PitchBend {
 
 /// A "meta message", as defined by the SMF spec.
 /// These events carry metadata about the track, such as tempo, time signature, copyright, etc...
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum MetaMessage<'a> {
     /// For `Format::Sequential` MIDI file types, `TrackNumber` can be empty, and defaults to
     /// the track index.

src/io.rs

@@ -58,7 +58,7 @@ impl<W> Clone for NotSeekable<W> {
 }
 impl<W> Copy for NotSeekable<W> {}
 impl<W> NotSeekable<W> {
-    fn never(self) -> ! {
+    pub fn as_never(&self) -> ! {
         match self.never {}
     }
 }
@@ -67,7 +67,7 @@ impl<W: Write> Write for NotSeekable<W> {
     type Error = W::Error;
     type Seekable = Self;
     fn write(&mut self, _: &[u8]) -> IoResult<Self> {
-        self.never()
+        self.as_never()
     }
     fn invalid_input(msg: &'static str) -> W::Error {
         W::invalid_input(msg)
@@ -76,10 +76,10 @@ impl<W: Write> Write for NotSeekable<W> {
 
 impl<W: Write> Seek for NotSeekable<W> {
     fn tell(&mut self) -> StdResult<u64, W::Error> {
-        self.never()
+        self.as_never()
     }
     fn write_at(&mut self, _: &[u8], _: u64) -> IoResult<Self> {
-        self.never()
+        self.as_never()
     }
 }
 
@@ -129,6 +129,7 @@ impl Seek for Vec<u8> {
 /// A seekable writer over an in-memory buffer.
 ///
 /// Available even when the `std` and `alloc` features are disabled.
+#[derive(Debug)]
 pub struct Cursor<'a> {
     buf: &'a mut [u8],
     cur: usize,
@@ -239,6 +240,7 @@ impl<'a> Seek for Cursor<'a> {
 }
 
 /// The errors that can arise when writing to an in-memory buffer.
+#[derive(Debug, Clone)]
 pub enum CursorError {
     /// The in-memory buffer was too small.
     OutOfSpace,
@@ -268,6 +270,7 @@ impl<'a> Write for &'a mut [u8] {
 /// Bridge between a `midly::io::Write` type and a `std::io::Write` type.
 ///
 /// Always available, but only implements `midly::io::Write` when the `std` feature is enabled.
+#[derive(Debug, Clone, Default)]
 pub struct IoWrap<T>(pub T);
 #[cfg(feature = "std")]
 impl<T: io::Write> Write for IoWrap<T> {
@@ -285,6 +288,7 @@ impl<T: io::Write> Write for IoWrap<T> {
 ///
 /// Always available, but only implements `midly::io::{Write, Seek}` when the `std` feature is
 /// enabled.
+#[derive(Debug, Clone, Default)]
 pub struct SeekableWrap<T>(pub T);
 #[cfg(feature = "std")]
 impl<T: io::Write + io::Seek> Write for SeekableWrap<T> {

src/lib.rs

@@ -108,13 +108,14 @@
 //!             vel: 127.into(),
 //!         },
 //!     };
+//! #   let mut stack_buf = [0; 3];
 //! #   let mut buf = {
 //! #       #[cfg(feature = "alloc")] {
 //!     let mut buf = Vec::new();
 //! #           buf
 //! #       }
 //! #       #[cfg(not(feature = "alloc"))] {
-//! #           [0; 3]
+//! #           &mut stack_buf[..]
 //! #       }
 //! #   };
 //!     ev.write(&mut buf).unwrap();
@@ -183,9 +184,11 @@ mod error;
 
 #[macro_use]
 mod prelude {
+    #[cfg(feature = "std")]
+    pub(crate) use crate::io::IoWrap;
     pub(crate) use crate::{
         error::{ErrorKind, Result, ResultExt, StdResult},
-        io::{IoResult, IoWrap, Seek, Write, WriteCounter},
+        io::{IoResult, Seek, Write, WriteCounter},
         primitive::{u14, u24, u28, u4, u7, IntRead, IntReadBottom7, SplitChecked},
     };
     #[cfg(feature = "alloc")]

src/live.rs

@@ -20,7 +20,7 @@ use crate::{event::MidiMessage, prelude::*};
 /// [`TrackEvent`](../struct.TrackEvent.html)s stored in a `.mid` file.
 ///
 /// See the [`live`](index.html) module for more information.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum LiveEvent<'a> {
     /// A MIDI message associated with a channel, carrying musical data.
     Midi { channel: u4, message: MidiMessage },
@@ -94,13 +94,19 @@ impl<'a> LiveEvent<'a> {
     }
 
     /// Write a standalone message to the given `std::io::Write` output.
+    ///
+    /// This method is only available with the `std` feature enabled.
+    #[cfg(feature = "std")]
     pub fn write_std<W: io::Write>(&self, out: W) -> io::Result<()> {
         self.write(&mut IoWrap(out))
     }
 
     /// Write a message, skipping the status if it shares the status with the previous message.
     ///
     /// Note that it's usually discouraged to feed messages with running status to OS APIs.
+    ///
+    /// This method is only available with the `std` feature enabled.
+    #[cfg(feature = "std")]
     pub fn write_std_with_running_status<W: io::Write>(
         &self,
         running_status: &mut Option<u8>,
@@ -113,7 +119,7 @@ impl<'a> LiveEvent<'a> {
 /// System Realtime messages are one-byte messages that only occur within live MIDI streams.
 /// They are usually time-sensitive, get top priority and can even be transmitted in between other
 /// messages.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum SystemRealtime {
     /// If sent, they should be sent 24 times per quarter note.
     TimingClock,
@@ -161,7 +167,7 @@ impl SystemRealtime {
 }
 
 /// A "system common event", as defined by the MIDI spec.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum SystemCommon<'a> {
     /// A system-exclusive event.
     ///
@@ -245,7 +251,7 @@ impl<'a> SystemCommon<'a> {
 }
 
 /// The different kinds of info a Midi Time Code Quarter Frame message can carry.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum MtcQuarterFrameMessage {
     /// The low nibble of the frame count.
     FramesLow,

src/primitive.rs

@@ -92,7 +92,7 @@ macro_rules! int_feature {
 macro_rules! restricted_int {
     {$(#[$attr:meta])* $name:ident : $inner:tt => $bits:expr ; $( $feature:tt )* } => {
         $(#[$attr])*
-        #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+        #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
         #[repr(transparent)]
         #[allow(non_camel_case_types)]
         pub struct $name($inner);
@@ -284,7 +284,7 @@ pub(crate) fn write_varlen_slice<W: Write>(slice: &[u8], out: &mut W) -> IoResul
 }
 
 /// The order in which tracks should be laid out when playing back this SMF file.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Format {
     /// This file should have a single track only.
     ///
@@ -323,7 +323,7 @@ impl Format {
 
 /// The timing for an SMF file.
 /// This can be in ticks/beat or ticks/second.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Timing {
     /// Specifies ticks/beat as a 15-bit integer.
     ///
@@ -370,7 +370,7 @@ impl Timing {
 /// - `second` is inside [0,59]
 /// - `frame` is inside [0,fps[
 /// - `subframe` is inside [0,99]
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct SmpteTime {
     hour: u8,
     minute: u8,
@@ -459,7 +459,7 @@ impl SmpteTime {
 }
 
 /// One of the four FPS values available for SMPTE times, as defined by the MIDI standard.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Fps {
     /// 24 frames per second.
     Fps24,