commenting and rustfmt for device

src/platform/windows/asio/device.rs

@@ -3,21 +3,25 @@ use std;
 pub type SupportedInputFormats = std::vec::IntoIter<SupportedFormat>;
 pub type SupportedOutputFormats = std::vec::IntoIter<SupportedFormat>;
 
+use std::hash::{Hash, Hasher};
+use DefaultFormatError;
 use Format;
 use FormatsEnumerationError;
-use DefaultFormatError;
-use SupportedFormat;
 use SampleFormat;
 use SampleRate;
-use std::hash::{Hash, Hasher};
+use SupportedFormat;
 
+/// A ASIO Device
 #[derive(Debug, Clone)]
-pub struct Device{
+pub struct Device {
+    /// The drivers for this device
     pub drivers: sys::Drivers,
+    /// The name of this device
     pub name: String,
 }
 
-pub struct Devices{
+/// All available devices
+pub struct Devices {
     drivers: std::vec::IntoIter<String>,
 }
 
@@ -40,40 +44,46 @@ impl Device {
         self.name.clone()
     }
 
-    // Just supporting default for now
+    /// Gets the supported input formats.
-    pub fn supported_input_formats(&self) -> Result<SupportedInputFormats, 
+    /// TODO currently only supports the default.
-    FormatsEnumerationError> {
+    /// Need to find all possible formats.
+    pub fn supported_input_formats(
+        &self,
+    ) -> Result<SupportedInputFormats, FormatsEnumerationError> {
         match self.default_input_format() {
             Ok(f) => {
+                // Can this device support both 44100 and 48000
                 let supported_formats: Vec<SupportedFormat> = [44100, 48000]
                     .into_iter()
-                    .filter(|rate| self.drivers.can_sample_rate(**rate as u32) )
+                    .filter(|rate| self.drivers.can_sample_rate(**rate as u32))
                     .map(|rate| {
                         let mut format = f.clone();
                         format.sample_rate = SampleRate(*rate);
                         SupportedFormat::from(format)
-                    })
+                    }).collect();
-                    .collect();
-                //Ok(vec![SupportedFormat::from(f)].into_iter())
                 Ok(supported_formats.into_iter())
             },
             Err(_) => Err(FormatsEnumerationError::DeviceNotAvailable),
         }
     }
 
-    pub fn supported_output_formats(&self) -> Result<SupportedOutputFormats, 
+    /// Gets the supported output formats.
-    FormatsEnumerationError> {
+    /// TODO currently only supports the default.
+    /// Need to find all possible formats.
+    pub fn supported_output_formats(
+        &self,
+    ) -> Result<SupportedOutputFormats, FormatsEnumerationError> {
         match self.default_output_format() {
             Ok(f) => {
+                // Can this device support both 44100 and 48000
                 let supported_formats: Vec<SupportedFormat> = [44100, 48000]
                     .into_iter()
-                    .filter(|rate| self.drivers.can_sample_rate(**rate as u32) )
+                    .filter(|rate| self.drivers.can_sample_rate(**rate as u32))
                     .map(|rate| {
                         let mut format = f.clone();
                         format.sample_rate = SampleRate(*rate);
                         SupportedFormat::from(format)
-                    })
+                    }).collect();
-                    .collect();
                 //Ok(vec![SupportedFormat::from(f)].into_iter())
                 Ok(supported_formats.into_iter())
             },
@@ -81,9 +91,11 @@ impl Device {
         }
     }
 
+    /// Returns the default input format
     pub fn default_input_format(&self) -> Result<Format, DefaultFormatError> {
         let channels = self.drivers.get_channels().ins as u16;
         let sample_rate = SampleRate(self.drivers.get_sample_rate().rate);
+        // Map th ASIO sample type to a CPAL sample type
         match self.drivers.get_data_type() {
             Ok(sys::AsioSampleType::ASIOSTInt16MSB) => Ok(SampleFormat::I16),
             Ok(sys::AsioSampleType::ASIOSTInt32MSB) => Ok(SampleFormat::I16),
@@ -92,28 +104,29 @@ impl Device {
             Ok(sys::AsioSampleType::ASIOSTInt32LSB) => Ok(SampleFormat::I16),
             Ok(sys::AsioSampleType::ASIOSTFloat32LSB) => Ok(SampleFormat::F32),
             _ => Err(DefaultFormatError::StreamTypeNotSupported),
-        }.map(|dt| {
+        }.map(|dt| Format {
-            Format{channels,
+            channels,
             sample_rate,
-            data_type: dt }
+            data_type: dt,
         })
     }
 
+    /// Returns the default output format
     pub fn default_output_format(&self) -> Result<Format, DefaultFormatError> {
         let channels = self.drivers.get_channels().outs as u16;
         let sample_rate = SampleRate(self.drivers.get_sample_rate().rate);
         match self.drivers.get_data_type() {
+            // Map th ASIO sample type to a CPAL sample type
             Ok(sys::AsioSampleType::ASIOSTInt16MSB) => Ok(SampleFormat::I16),
             Ok(sys::AsioSampleType::ASIOSTFloat32MSB) => Ok(SampleFormat::F32),
             Ok(sys::AsioSampleType::ASIOSTInt16LSB) => Ok(SampleFormat::I16),
-            // TODO This should not be set to 16bit but is for testing
             Ok(sys::AsioSampleType::ASIOSTInt32LSB) => Ok(SampleFormat::I16),
             Ok(sys::AsioSampleType::ASIOSTFloat32LSB) => Ok(SampleFormat::F32),
             _ => Err(DefaultFormatError::StreamTypeNotSupported),
-        }.map(|dt|{
+        }.map(|dt| Format {
-            Format{channels,
+            channels,
             sample_rate,
-            data_type: dt }
+            data_type: dt,
         })
     }
 }
@@ -125,25 +138,24 @@ impl Default for Devices {
             .into_iter()
             .filter(|name| sys::Drivers::load(&name).is_ok())
             .collect();
-        Devices{ drivers: driver_names.into_iter() }
+        Devices {
-
+            drivers: driver_names.into_iter(),
+        }
     }
 }
 
 impl Iterator for Devices {
     type Item = Device;
 
+    /// Load drivers and return device
     fn next(&mut self) -> Option<Device> {
         match self.drivers.next() {
-            Some(name) => {
+            Some(name) => sys::Drivers::load(&name)
-                sys::Drivers::load(&name)
                 .or_else(|e| {
                     eprintln!("{}", e);
                     Err(e)
-                        })
+                }).ok()
-                    .ok()
+                .map(|drivers| Device { drivers, name }),
-                    .map(|drivers| Device{drivers, name} )
-            },
             None => None,
         }
     }
@@ -153,36 +165,32 @@ impl Iterator for Devices {
     }
 }
 
-// Asio doesn't have a concept of default
+/// Asio doesn't have a concept of default
-// so returning first in list as default
+/// so returning first in list as default
 pub fn default_input_device() -> Option<Device> {
     let mut driver_list = sys::get_driver_list();
     match driver_list.pop() {
-        Some(name) => {
+        Some(name) => sys::Drivers::load(&name)
-            sys::Drivers::load(&name)
             .or_else(|e| {
                 eprintln!("{}", e);
                 Err(e)
-                    })
+            }).ok()
-                .ok()
+            .map(|drivers| Device { drivers, name }),
-                .map(|drivers| Device{drivers, name} )
-        },
         None => None,
     }
 }
 
+/// Asio doesn't have a concept of default
+/// so returning first in list as default
 pub fn default_output_device() -> Option<Device> {
     let mut driver_list = sys::get_driver_list();
     match driver_list.pop() {
-        Some(name) => {
+        Some(name) => sys::Drivers::load(&name)
-            sys::Drivers::load(&name)
             .or_else(|e| {
                 eprintln!("{}", e);
                 Err(e)
-                    })
+            }).ok()
-                .ok()
+            .map(|drivers| Device { drivers, name }),
-                .map(|drivers| Device{drivers, name} )
-        },
         None => None,
     }
 }