Merge branch 'mutable-references' into next

RFC:
	https://lists.sr.ht/~ireas/nitrokey-rs-dev/%3C20190126174327.tbuyk2s535kfiqm4%40localhost%3E
	https://lists.sr.ht/~ireas/nitrokey-rs-dev/%3C43cc304d-23e8-7f95-2167-ce3f0530b81e%40posteo.net%3E

* mutable-references:
  Store mutable reference to Device in PasswordSafe
  Refactor User and Admin to use a mutable reference
  Require mutable reference if method changes device state
  Add device_mut method to DeviceWrapper
  Implement DerefMut for User and Admin

1 files changed, 21 insertions, 21 deletions

diff --git a/src/otp.rs b/src/otp.rs
index abaff66..a8dd20b 100644
--- a/src/otp.rs
+++ b/src/otp.rs
@@ -35,16 +35,16 @@ pub trait ConfigureOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::SixDigits);
     /// match device.authenticate_admin("12345678") {
-    ///     Ok(admin) => {
+    ///     Ok(mut admin) => {
     ///         match admin.write_hotp_slot(slot_data, 0) {
     ///             Ok(()) => println!("Successfully wrote slot."),
     ///             Err(err) => eprintln!("Could not write slot: {}", err),
     ///         }
     ///     },
-    ///     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
+    ///     Err(err) => eprintln!("Could not authenticate as admin: {}", err),
     /// }
     /// #     Ok(())
     /// # }
@@ -53,7 +53,7 @@ pub trait ConfigureOtp {
     /// [`InvalidSlot`]: enum.LibraryError.html#variant.InvalidSlot
     /// [`InvalidString`]: enum.LibraryError.html#variant.InvalidString
     /// [`NoName`]: enum.CommandError.html#variant.NoName
-    fn write_hotp_slot(&self, data: OtpSlotData, counter: u64) -> Result<(), Error>;
+    fn write_hotp_slot(&mut self, data: OtpSlotData, counter: u64) -> Result<(), Error>;
 
     /// Configure a TOTP slot with the given data and set the TOTP time window to the given value
     /// (default 30).
@@ -71,16 +71,16 @@ pub trait ConfigureOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::EightDigits);
     /// match device.authenticate_admin("12345678") {
-    ///     Ok(admin) => {
+    ///     Ok(mut admin) => {
     ///         match admin.write_totp_slot(slot_data, 30) {
     ///             Ok(()) => println!("Successfully wrote slot."),
     ///             Err(err) => eprintln!("Could not write slot: {}", err),
     ///         }
     ///     },
-    ///     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
+    ///     Err(err) => eprintln!("Could not authenticate as admin: {}", err),
     /// }
     /// #     Ok(())
     /// # }
@@ -89,7 +89,7 @@ pub trait ConfigureOtp {
     /// [`InvalidSlot`]: enum.LibraryError.html#variant.InvalidSlot
     /// [`InvalidString`]: enum.LibraryError.html#variant.InvalidString
     /// [`NoName`]: enum.CommandError.html#variant.NoName
-    fn write_totp_slot(&self, data: OtpSlotData, time_window: u16) -> Result<(), Error>;
+    fn write_totp_slot(&mut self, data: OtpSlotData, time_window: u16) -> Result<(), Error>;
 
     /// Erases an HOTP slot.
     ///
@@ -104,22 +104,22 @@ pub trait ConfigureOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// match device.authenticate_admin("12345678") {
-    ///     Ok(admin) => {
+    ///     Ok(mut admin) => {
     ///         match admin.erase_hotp_slot(1) {
     ///             Ok(()) => println!("Successfully erased slot."),
     ///             Err(err) => eprintln!("Could not erase slot: {}", err),
     ///         }
     ///     },
-    ///     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
+    ///     Err(err) => eprintln!("Could not authenticate as admin: {}", err),
     /// }
     /// #     Ok(())
     /// # }
     /// ```
     ///
     /// [`InvalidSlot`]: enum.LibraryError.html#variant.InvalidSlot
-    fn erase_hotp_slot(&self, slot: u8) -> Result<(), Error>;
+    fn erase_hotp_slot(&mut self, slot: u8) -> Result<(), Error>;
 
     /// Erases a TOTP slot.
     ///
@@ -134,22 +134,22 @@ pub trait ConfigureOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// match device.authenticate_admin("12345678") {
-    ///     Ok(admin) => {
+    ///     Ok(mut admin) => {
     ///         match admin.erase_totp_slot(1) {
     ///             Ok(()) => println!("Successfully erased slot."),
     ///             Err(err) => eprintln!("Could not erase slot: {}", err),
     ///         }
     ///     },
-    ///     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
+    ///     Err(err) => eprintln!("Could not authenticate as admin: {}", err),
     /// }
     /// #     Ok(())
     /// # }
     /// ```
     ///
     /// [`InvalidSlot`]: enum.LibraryError.html#variant.InvalidSlot
-    fn erase_totp_slot(&self, slot: u8) -> Result<(), Error>;
+    fn erase_totp_slot(&mut self, slot: u8) -> Result<(), Error>;
 }
 
 /// Provides methods to generate OTP codes and to query OTP slots on a Nitrokey
@@ -171,7 +171,7 @@ pub trait GenerateOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// let time = time::SystemTime::now().duration_since(time::UNIX_EPOCH);
     /// match time {
     ///     Ok(time) => device.set_time(time.as_secs(), false)?,
@@ -187,7 +187,7 @@ pub trait GenerateOtp {
     ///
     /// [`get_totp_code`]: #method.get_totp_code
     /// [`Timestamp`]: enum.CommandError.html#variant.Timestamp
-    fn set_time(&self, time: u64, force: bool) -> Result<(), Error> {
+    fn set_time(&mut self, time: u64, force: bool) -> Result<(), Error> {
         let result = if force {
             unsafe { nitrokey_sys::NK_totp_set_time(time) }
         } else {
@@ -270,7 +270,7 @@ pub trait GenerateOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// let code = device.get_hotp_code(1)?;
     /// println!("Generated HOTP code on slot 1: {}", code);
     /// #     Ok(())
@@ -281,7 +281,7 @@ pub trait GenerateOtp {
     /// [`InvalidSlot`]: enum.LibraryError.html#variant.InvalidSlot
     /// [`NotAuthorized`]: enum.CommandError.html#variant.NotAuthorized
     /// [`SlotNotProgrammed`]: enum.CommandError.html#variant.SlotNotProgrammed
-    fn get_hotp_code(&self, slot: u8) -> Result<String, Error> {
+    fn get_hotp_code(&mut self, slot: u8) -> Result<String, Error> {
         result_from_string(unsafe { nitrokey_sys::NK_get_hotp_code(slot) })
     }
 
@@ -305,7 +305,7 @@ pub trait GenerateOtp {
     /// # use nitrokey::Error;
     ///
     /// # fn try_main() -> Result<(), Error> {
-    /// let device = nitrokey::connect()?;
+    /// let mut device = nitrokey::connect()?;
     /// let time = time::SystemTime::now().duration_since(time::UNIX_EPOCH);
     /// match time {
     ///     Ok(time) => {