chore: create simple client

1 files changed, 192 insertions, 192 deletions

diff --git a/src/commands/stream_mapper.rs b/src/commands/stream_mapper.rs
index 2b6f612..4b13bc8 100644..100755
--- a/src/commands/stream_mapper.rs
+++ b/src/commands/stream_mapper.rs
@@ -1,192 +1,192 @@
-

-use regex::Regex;

-

-use std::collections::VecDeque;

-use std::collections::vec_deque::Drain;

-use std::convert::TryInto;

-

-use super::*;

-

-pub struct CommandToByteMapper {

-    buffer: VecDeque<u8>,

-}

-impl CommandToByteMapper {

-

-    pub fn new() -> CommandToByteMapper {

-        CommandToByteMapper{ buffer: VecDeque::new() }

-    }

-

-    pub fn map(&mut self, command: Command) -> Drain<u8> {

-        self.clear_buffer();

-

-        self.write_u8(command.opcode());

-        match command {

-            Command::GetInfo => {},

-            Command::CreateScanner {

-                scan_id,

-            } => {

-                

-                    self.write_u32(scan_id);

-            },

-            Command::RemoveScanner {

-                scan_id,

-            } => {

-                

-                    self.write_u32(scan_id);

-            },

-            Command::CreateConnectionChannel {

-                conn_id,

-                bd_addr,

-                latency_mode,

-                auto_disconnect_time,

-            } => {

-                

-                    self.write_u32(conn_id);

-                    self.write_bdaddr(&bd_addr[..]);

-                    if let Ok(latency_mode) = latency_mode.try_into() {

-                        self.write_u8(latency_mode);

-                    }

-                    self.write_i16(auto_disconnect_time);

-            },

-            Command::RemoveConnectionChannel {

-                conn_id,

-            } => {

-                

-                    self.write_u32(conn_id);

-            },

-            Command::ForceDisconnect {

-                bd_addr,

-            } => {

-                

-                    self.write_bdaddr(&bd_addr[..]);

-            },

-            Command::ChangeModeParameters {

-                conn_id,

-                latency_mode,

-                auto_disconnect_time,

-            } => {

-                

-                    self.write_u32(conn_id);

-                    if let Ok(latency_mode) = latency_mode.try_into() {

-                        self.write_u8(latency_mode);

-                    }

-                    self.write_i16(auto_disconnect_time);

-            },

-            Command::Ping {

-                ping_id,

-            } => {

-                

-                    self.write_u32(ping_id);

-            },

-            Command::GetButtonInfo {

-                bd_addr,

-            } => {

-                

-                    self.write_bdaddr(&bd_addr[..]);

-            },

-            Command::CreateScanWizard {

-                scan_wizard_id,

-            } => {

-                

-                    self.write_u32(scan_wizard_id);

-            },

-            Command::CancelScanWizard {

-                scan_wizard_id,

-            } => {

-                

-                    self.write_u32(scan_wizard_id);

-            },

-            Command::DeleteButton {

-                bd_addr,

-            } => {

-                

-                    self.write_bdaddr(&bd_addr[..]);

-            },

-            Command::CreateBatteryStatusListener {

-                listener_id,

-                bd_addr,

-            } => {

-                

-                    self.write_u32(listener_id);

-                    self.write_bdaddr(&bd_addr[..]);

-            },

-            Command::RemoveBatteryStatusListener {

-                listener_id,

-            } => {

-                

-                    self.write_u32(listener_id);

-            },

-        }

-

-        self.prepend_size();

-

-        self.buffer.drain(..)

-    }

-

-    fn clear_buffer(&mut self) {

-        self.buffer.drain(..);

-    }

-

-    fn prepend_size(&mut self) {

-        let len = self.buffer.len();

-        self.buffer.push_front((len >> 8) as u8);

-        self.buffer.push_front((len & 255) as u8);

-    }

-    fn write_u8(&mut self, value: u8) {

-        let mut buf = vec![value].into_iter().collect();

-        self.buffer.append(&mut buf);

-    }

-/*

-    fn write_bool(&mut self, value: bool) {

-        if value {

-            self.write_u8(1);

-        }

-        else {

-            self.write_u8(0);

-        }

-    }

-*/

-    fn write_u16(&mut self, value: u16) {

-        self.write_u8(value as u8);

-        self.write_u8((value >> 8) as u8);

-    }

-    fn write_i16(&mut self, value: i16) {

-        self.write_u8(value as u8);

-        self.write_u8((value >> 8) as u8);

-    }

-    fn write_u32(&mut self, value: u32) {

-        self.write_u16(value as u16);

-        self.write_u16((value >> 16) as u16);

-    }

-/*

-    fn write_i32(&mut self, value: i32) {

-        self.write_i16(value as i16);

-        self.write_i16((value >> 16) as i16);

-    }

-*/

-    fn write_bdaddr(&mut self, str: &str) {

-        let re = Regex::new(r"([0-9a-z]{2}:){5}[0-9a-z]{2}").unwrap();

-        if re.is_match(str) {

-            if let Some(b) = hex_to_u8(&str[15..]) { self.write_u8(b); }

-            if let Some(b) = hex_to_u8(&str[12..]) { self.write_u8(b); }

-            if let Some(b) = hex_to_u8(&str[ 9..]) { self.write_u8(b); }

-            if let Some(b) = hex_to_u8(&str[ 6..]) { self.write_u8(b); }

-            if let Some(b) = hex_to_u8(&str[ 3..]) { self.write_u8(b); }

-            if let Some(b) = hex_to_u8(&str[  ..]) { self.write_u8(b); }

-        }

-    }

-

-}

-

-fn hex_to_u8(buffer: &str) -> Option<u8> {

-    let mut char_indices = buffer.char_indices();

-    match (char_indices.next(), char_indices.next()) {

-        (Some((0, upper)), Some((1, lower))) => {

-            let mut b = 0u8;

-            if let Some(v) = upper.to_digit(16) { b += (v as u8) << 4; }

-            if let Some(v) = lower.to_digit(16) { b += v as u8; }

-            Some(b)

-        },

-        _ => None,

-    }

-}

+
+use regex::Regex;
+
+use std::collections::VecDeque;
+use std::collections::vec_deque::Drain;
+use std::convert::TryInto;
+
+use super::*;
+
+pub struct CommandToByteMapper {
+    buffer: VecDeque<u8>,
+}
+impl CommandToByteMapper {
+
+    pub fn new() -> CommandToByteMapper {
+        CommandToByteMapper{ buffer: VecDeque::new() }
+    }
+
+    pub fn map(&mut self, command: Command) -> Drain<u8> {
+        self.clear_buffer();
+
+        self.write_u8(command.opcode());
+        match command {
+            Command::GetInfo => {},
+            Command::CreateScanner {
+                scan_id,
+            } => {
+                
+                    self.write_u32(scan_id);
+            },
+            Command::RemoveScanner {
+                scan_id,
+            } => {
+                
+                    self.write_u32(scan_id);
+            },
+            Command::CreateConnectionChannel {
+                conn_id,
+                bd_addr,
+                latency_mode,
+                auto_disconnect_time,
+            } => {
+                
+                    self.write_u32(conn_id);
+                    self.write_bdaddr(&bd_addr[..]);
+                    if let Ok(latency_mode) = latency_mode.try_into() {
+                        self.write_u8(latency_mode);
+                    }
+                    self.write_i16(auto_disconnect_time);
+            },
+            Command::RemoveConnectionChannel {
+                conn_id,
+            } => {
+                
+                    self.write_u32(conn_id);
+            },
+            Command::ForceDisconnect {
+                bd_addr,
+            } => {
+                
+                    self.write_bdaddr(&bd_addr[..]);
+            },
+            Command::ChangeModeParameters {
+                conn_id,
+                latency_mode,
+                auto_disconnect_time,
+            } => {
+                
+                    self.write_u32(conn_id);
+                    if let Ok(latency_mode) = latency_mode.try_into() {
+                        self.write_u8(latency_mode);
+                    }
+                    self.write_i16(auto_disconnect_time);
+            },
+            Command::Ping {
+                ping_id,
+            } => {
+                
+                    self.write_u32(ping_id);
+            },
+            Command::GetButtonInfo {
+                bd_addr,
+            } => {
+                
+                    self.write_bdaddr(&bd_addr[..]);
+            },
+            Command::CreateScanWizard {
+                scan_wizard_id,
+            } => {
+                
+                    self.write_u32(scan_wizard_id);
+            },
+            Command::CancelScanWizard {
+                scan_wizard_id,
+            } => {
+                
+                    self.write_u32(scan_wizard_id);
+            },
+            Command::DeleteButton {
+                bd_addr,
+            } => {
+                
+                    self.write_bdaddr(&bd_addr[..]);
+            },
+            Command::CreateBatteryStatusListener {
+                listener_id,
+                bd_addr,
+            } => {
+                
+                    self.write_u32(listener_id);
+                    self.write_bdaddr(&bd_addr[..]);
+            },
+            Command::RemoveBatteryStatusListener {
+                listener_id,
+            } => {
+                
+                    self.write_u32(listener_id);
+            },
+        }
+
+        self.prepend_size();
+
+        self.buffer.drain(..)
+    }
+
+    fn clear_buffer(&mut self) {
+        self.buffer.drain(..);
+    }
+
+    fn prepend_size(&mut self) {
+        let len = self.buffer.len();
+        self.buffer.push_front((len >> 8) as u8);
+        self.buffer.push_front((len & 255) as u8);
+    }
+    fn write_u8(&mut self, value: u8) {
+        let mut buf = vec![value].into_iter().collect();
+        self.buffer.append(&mut buf);
+    }
+/*
+    fn write_bool(&mut self, value: bool) {
+        if value {
+            self.write_u8(1);
+        }
+        else {
+            self.write_u8(0);
+        }
+    }
+*/
+    fn write_u16(&mut self, value: u16) {
+        self.write_u8(value as u8);
+        self.write_u8((value >> 8) as u8);
+    }
+    fn write_i16(&mut self, value: i16) {
+        self.write_u8(value as u8);
+        self.write_u8((value >> 8) as u8);
+    }
+    fn write_u32(&mut self, value: u32) {
+        self.write_u16(value as u16);
+        self.write_u16((value >> 16) as u16);
+    }
+/*
+    fn write_i32(&mut self, value: i32) {
+        self.write_i16(value as i16);
+        self.write_i16((value >> 16) as i16);
+    }
+*/
+    fn write_bdaddr(&mut self, str: &str) {
+        let re = Regex::new(r"([0-9a-z]{2}:){5}[0-9a-z]{2}").unwrap();
+        if re.is_match(str) {
+            if let Some(b) = hex_to_u8(&str[15..]) { self.write_u8(b); }
+            if let Some(b) = hex_to_u8(&str[12..]) { self.write_u8(b); }
+            if let Some(b) = hex_to_u8(&str[ 9..]) { self.write_u8(b); }
+            if let Some(b) = hex_to_u8(&str[ 6..]) { self.write_u8(b); }
+            if let Some(b) = hex_to_u8(&str[ 3..]) { self.write_u8(b); }
+            if let Some(b) = hex_to_u8(&str[  ..]) { self.write_u8(b); }
+        }
+    }
+
+}
+
+fn hex_to_u8(buffer: &str) -> Option<u8> {
+    let mut char_indices = buffer.char_indices();
+    match (char_indices.next(), char_indices.next()) {
+        (Some((0, upper)), Some((1, lower))) => {
+            let mut b = 0u8;
+            if let Some(v) = upper.to_digit(16) { b += (v as u8) << 4; }
+            if let Some(v) = lower.to_digit(16) { b += v as u8; }
+            Some(b)
+        },
+        _ => None,
+    }
+}