Switch from libusb to rusb

Author: lkolbly

Cargo.toml

@@ -10,7 +10,7 @@ authors = ["Matti Virkkunen <[email protected]>"]
 repository = "https://github.com/mvirkkunen/usb-device"
 
 [dev-dependencies]
-libusb = "0.3.0"
+rusb = "0.8.0"
 rand = "0.6.1"
 
 [features]

tests/test_class_host/device.rs

@@ -1,32 +1,32 @@
 use std::time::Duration;
-use libusb::*;
+use rusb::*;
 use usb_device::test_class;
 
 pub const TIMEOUT: Duration = Duration::from_secs(1);
 pub const EN_US: u16 = 0x0409;
 
-pub struct DeviceHandles<'a> {
+pub struct DeviceHandles {
     pub device_descriptor: DeviceDescriptor,
     pub config_descriptor: ConfigDescriptor,
-    pub handle: DeviceHandle<'a>,
+    pub handle: DeviceHandle<Context>,
     pub en_us: Language,
 }
 
-impl<'a> ::std::ops::Deref for DeviceHandles<'a> {
-    type Target = DeviceHandle<'a>;
+impl ::std::ops::Deref for DeviceHandles {
+    type Target = DeviceHandle<Context>;
 
-    fn deref(&self) -> &DeviceHandle<'a> {
+    fn deref(&self) -> &DeviceHandle<Context> {
         &self.handle
     }
 }
 
-impl<'a> ::std::ops::DerefMut for DeviceHandles<'a> {
-    fn deref_mut(&mut self) -> &mut DeviceHandle<'a> {
+impl ::std::ops::DerefMut for DeviceHandles {
+    fn deref_mut(&mut self) -> &mut DeviceHandle<Context> {
         &mut self.handle
     }
 }
 
-pub fn open_device(ctx: &Context) -> libusb::Result<DeviceHandles<'_>> {
+pub fn open_device(ctx: &Context) -> rusb::Result<DeviceHandles> {
     for device in ctx.devices()?.iter() {
         let device_descriptor = device.device_descriptor()?;
 
@@ -58,5 +58,5 @@ pub fn open_device(ctx: &Context) -> libusb::Result<DeviceHandles<'_>> {
         }
     }
 
-    Err(libusb::Error::NoDevice)
+    Err(rusb::Error::NoDevice)
 }

tests/test_class_host/main.rs

@@ -12,7 +12,7 @@ use std::io::prelude::*;
 use std::thread;
 use std::time::Duration;
 use std::panic;
-use libusb::*;
+use rusb::*;
 use usb_device::device::CONFIGURATION_VALUE;
 use crate::device::open_device;
 use crate::tests::{TestFn, get_tests};
@@ -31,7 +31,7 @@ fn run_tests(tests: &[(&str, TestFn)]) {
     let ctx = Context::new().expect("create libusb context");
 
     // Look for the device for about 5 seconds in case it hasn't finished enumerating yet
-    let mut dev = Err(libusb::Error::NoDevice);
+    let mut dev = Err(rusb::Error::NoDevice);
     for _ in 0..50 {
         dev = open_device(&ctx);
         if dev.is_ok() {

tests/test_class_host/tests.rs

@@ -1,7 +1,7 @@
 use std::cmp::max;
 use std::fmt::Write;
 use std::time::{Duration, Instant};
-use libusb::*;
+use rusb::*;
 use rand::prelude::*;
 use usb_device::test_class;
 use crate::device::*;
@@ -16,7 +16,7 @@ macro_rules! tests {
             let mut tests: Vec<(&'static str, TestFn)> = Vec::new();
 
             $(
-                fn $name($dev: &mut DeviceHandles<'_>, $out: &mut String) {
+                fn $name($dev: &mut DeviceHandles, $out: &mut String) {
                     $body
                 }