Skip to content

Commit 014fed9

Browse files
committed
Revert changes with no measurable gain
1 parent ba42af6 commit 014fed9

4 files changed

Lines changed: 111 additions & 114 deletions

File tree

‎src/device_selector.rs‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -201,13 +201,12 @@ impl DeviceSelector {
201201
}
202202

203203
fn get_report_descriptor(&self, dev: &ISPHandle) -> Result<Vec<u8>, DeviceSelectorError> {
204-
let mut buf = vec![0; MAX_REPORT_DESCRIPTOR_SIZE];
204+
let mut buf: [u8; MAX_REPORT_DESCRIPTOR_SIZE] = [0; MAX_REPORT_DESCRIPTOR_SIZE];
205205
let size: usize = dev
206206
.get_report_descriptor(&mut buf)
207207
.wait()
208208
.map_err(DeviceSelectorError::from)?;
209-
buf.truncate(size);
210-
Ok(buf)
209+
Ok(buf[..size].to_vec())
211210
}
212211

213212
fn get_descriptor_with_features(

‎src/hid_tree.rs‎

Lines changed: 100 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,3 @@
1-
use std::fmt::Write;
2-
31
use crate::device_selector::DeviceSelectorError;
42
use sinowisp::to_hex_string;
53

@@ -39,122 +37,140 @@ pub struct ItemNode {
3937

4038
const INDENT_SIZE: usize = 4;
4139

42-
pub trait TreeDisplay: Sized {
43-
fn write_tree(self, out: &mut String, level: usize);
44-
45-
fn to_tree_string(self, level: usize) -> String {
46-
let mut out = String::new();
47-
self.write_tree(&mut out, level);
48-
out
49-
}
50-
}
51-
52-
fn push_indent(out: &mut String, level: usize) {
53-
out.extend(std::iter::repeat_n(' ', INDENT_SIZE * level));
54-
}
55-
56-
fn write_descriptor_lines(
57-
out: &mut String,
58-
level: usize,
59-
descriptor: &Result<Vec<u8>, DeviceSelectorError>,
60-
feature_report_ids: &Result<Vec<u32>, DeviceSelectorError>,
61-
) {
62-
out.push('\n');
63-
push_indent(out, level);
64-
let _ = match descriptor {
65-
Ok(descriptor) => write!(out, "report_descriptor=[{}]", to_hex_string(descriptor)),
66-
Err(e) => write!(out, "report_descriptor=error: {e}"),
67-
};
68-
out.push('\n');
69-
push_indent(out, level);
70-
match feature_report_ids {
71-
Ok(feature_report_ids) => {
72-
out.push_str("feature_report_ids=[");
73-
for (i, rid) in feature_report_ids.iter().enumerate() {
74-
if i > 0 {
75-
out.push_str(", ");
76-
}
77-
let _ = write!(out, "{rid}");
78-
}
79-
out.push(']');
80-
}
81-
Err(e) => {
82-
let _ = write!(out, "feature_report_ids=error: {e}");
83-
}
84-
}
40+
pub trait TreeDisplay {
41+
fn to_tree_string(self, level: usize) -> String;
8542
}
8643

8744
impl<T, I> TreeDisplay for T
8845
where
8946
T: Iterator<Item = I>,
9047
I: TreeDisplay,
9148
{
92-
fn write_tree(self, out: &mut String, level: usize) {
93-
for (i, item) in self.enumerate() {
94-
if i > 0 {
95-
out.push('\n');
96-
}
97-
push_indent(out, level);
98-
item.write_tree(out, level);
49+
fn to_tree_string(self, level: usize) -> String {
50+
let indent = " ".repeat(INDENT_SIZE).repeat(level);
51+
let mut s: Vec<String> = vec![];
52+
for item in self {
53+
s.push(format!("{}{}", indent, item.to_tree_string(level)));
9954
}
55+
s.join("\n")
10056
}
10157
}
10258

10359
impl TreeDisplay for DeviceNode {
104-
fn write_tree(self, out: &mut String, level: usize) {
105-
push_indent(out, level);
106-
let _ = write!(
107-
out,
108-
"ID {:04x}:{:04x} manufacturer=\"{}\" product=\"{}\"",
60+
fn to_tree_string(self, level: usize) -> String {
61+
let indent = " ".repeat(INDENT_SIZE).repeat(level);
62+
let mut s: Vec<String> = vec![];
63+
s.push(format!(
64+
"{indent}ID {:04x}:{:04x} manufacturer=\"{:}\" product=\"{:}\"",
10965
self.vendor_id, self.product_id, self.manufacturer_string, self.product_string
110-
);
66+
));
11167
for child in self.children {
112-
out.push('\n');
113-
child.write_tree(out, level + 1);
68+
s.push(child.to_tree_string(level + 1));
11469
}
70+
s.join("\n")
11571
}
11672
}
11773

11874
impl TreeDisplay for InterfaceNode {
119-
fn write_tree(self, out: &mut String, level: usize) {
120-
push_indent(out, level);
75+
fn to_tree_string(self, level: usize) -> String {
76+
let indent = " ".repeat(INDENT_SIZE).repeat(level);
77+
let mut s: Vec<String> = vec![];
78+
#[cfg(any(target_os = "macos", target_os = "linux"))]
79+
s.push(format!(
80+
"{indent}path=\"{}\" interface_number={}",
81+
self.path, self.interface_number
82+
));
83+
#[cfg(target_os = "windows")]
84+
s.push(format!(
85+
"{indent}interface_number={}",
86+
self.interface_number
87+
));
12188
#[cfg(any(target_os = "macos", target_os = "linux"))]
12289
{
123-
let _ = write!(
124-
out,
125-
"path=\"{}\" interface_number={}",
126-
self.path, self.interface_number
127-
);
128-
write_descriptor_lines(out, level, &self.descriptor, &self.feature_report_ids);
90+
let descriptor = self.descriptor.as_ref();
91+
match descriptor {
92+
Ok(descriptor) => {
93+
s.push(format!(
94+
"{indent}report_descriptor=[{}]",
95+
to_hex_string(descriptor)
96+
));
97+
}
98+
Err(e) => {
99+
s.push(format!("{indent}report_descriptor=error: {e}"));
100+
}
101+
}
102+
let feature_report_ids = self.feature_report_ids.as_ref();
103+
match feature_report_ids {
104+
Ok(feature_report_ids) => {
105+
s.push(format!(
106+
"{indent}feature_report_ids=[{}]",
107+
feature_report_ids
108+
.iter()
109+
.map(|rid| format!("{rid}"))
110+
.collect::<Vec<String>>()
111+
.join(", ")
112+
));
113+
}
114+
Err(e) => {
115+
s.push(format!("{indent}feature_report_ids=error: {e}"));
116+
}
117+
}
129118
}
130-
#[cfg(target_os = "windows")]
131-
let _ = write!(out, "interface_number={}", self.interface_number);
132119
#[cfg(any(target_os = "macos", target_os = "windows"))]
133-
for child in self.children {
134-
out.push('\n');
135-
child.write_tree(out, level + 1);
120+
{
121+
for child in self.children {
122+
s.push(child.to_tree_string(level + 1));
123+
}
136124
}
125+
s.join("\n")
137126
}
138127
}
139128

140129
#[cfg(any(target_os = "macos", target_os = "windows"))]
141130
impl TreeDisplay for ItemNode {
142-
fn write_tree(self, out: &mut String, level: usize) {
143-
push_indent(out, level);
131+
fn to_tree_string(self, level: usize) -> String {
132+
let indent = " ".repeat(INDENT_SIZE).repeat(level);
133+
let mut s: Vec<String> = vec![];
144134
#[cfg(target_os = "macos")]
145-
let _ = write!(
146-
out,
147-
"usage_page={:#06x} usage={:#06x}",
135+
s.push(format!(
136+
"{indent}usage_page={:#06x} usage={:#06x}",
148137
self.usage_page, self.usage
149-
);
138+
));
150139
#[cfg(target_os = "windows")]
151140
{
152-
let _ = write!(
153-
out,
154-
"path=\"{}\" usage_page={:#06x} usage={:#06x}",
141+
s.push(format!(
142+
"{indent}path=\"{}\" usage_page={:#06x} usage={:#06x}",
155143
self.path, self.usage_page, self.usage
156-
);
157-
write_descriptor_lines(out, level, &self.descriptor, &self.feature_report_ids);
144+
));
145+
let descriptor = self.descriptor.as_ref();
146+
match descriptor {
147+
Ok(descriptor) => {
148+
s.push(format!(
149+
"{indent}report_descriptor=[{}]",
150+
to_hex_string(descriptor)
151+
));
152+
}
153+
Err(e) => {
154+
s.push(format!("{indent}report_descriptor=error: {}", e));
155+
}
156+
}
157+
let feature_report_ids = self.feature_report_ids.as_ref();
158+
match feature_report_ids {
159+
Ok(feature_report_ids) => {
160+
s.push(format!(
161+
"{indent}feature_report_ids=[{}]",
162+
feature_report_ids
163+
.iter()
164+
.map(|rid| format!("{}", rid))
165+
.collect::<Vec<String>>()
166+
.join(", ")
167+
));
168+
}
169+
Err(e) => {
170+
s.push(format!("{indent}feature_report_ids=error: {}", e));
171+
}
172+
}
158173
}
174+
s.join("\n")
159175
}
160176
}

‎src/isp_device.rs‎

Lines changed: 7 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -223,15 +223,11 @@ impl ISPDevice {
223223

224224
/// Reads one page of flash contents, appending it to `buf`.
225225
pub async fn read_page(&self, buf: &mut Vec<u8>) -> Result<(), ISPError> {
226-
let mut xfer_buf = vec![0; self.device_spec.platform.page_size + 2];
227-
self.read_page_with(&mut xfer_buf, buf).await
228-
}
229-
230-
async fn read_page_with(&self, xfer_buf: &mut [u8], buf: &mut Vec<u8>) -> Result<(), ISPError> {
231226
let page_size = self.device_spec.platform.page_size;
227+
let mut xfer_buf: Vec<u8> = vec![0; page_size + 2];
232228
xfer_buf[0] = REPORT_ID_XFER;
233229
self.xfer_device()
234-
.get_feature_report(xfer_buf)
230+
.get_feature_report(&mut xfer_buf)
235231
.await
236232
.map_err(ISPError::from)?;
237233
let page = &xfer_buf[2..(page_size + 2)];
@@ -256,12 +252,8 @@ impl ISPDevice {
256252
/// <firmware_size-4> and will later be part of the LJMP instruction after the firmware is
257253
/// enabled (`enable_firmware`). This only works once after an erase operation.
258254
pub async fn write_page(&self, buf: &[u8]) -> Result<(), ISPError> {
259-
let mut xfer_buf = vec![0; buf.len() + 2];
260-
self.write_page_with(&mut xfer_buf, buf).await
261-
}
262-
263-
async fn write_page_with(&self, xfer_buf: &mut [u8], buf: &[u8]) -> Result<(), ISPError> {
264255
let length = buf.len() + 2;
256+
let mut xfer_buf: Vec<u8> = vec![0; length];
265257
xfer_buf[0] = REPORT_ID_XFER;
266258
xfer_buf[1] = XFER_WRITE_PAGE;
267259
match self.device_spec.isp_transform {
@@ -270,10 +262,10 @@ impl ISPDevice {
270262
*dst = (transform.write)(i, *src);
271263
}
272264
}
273-
None => xfer_buf[2..length].copy_from_slice(buf),
265+
None => xfer_buf[2..length].clone_from_slice(buf),
274266
}
275267
self.xfer_device()
276-
.send_feature_report(&xfer_buf[..length])
268+
.send_feature_report(&xfer_buf)
277269
.await
278270
.map_err(ISPError::from)?;
279271
if xfer_buf[1] != XFER_WRITE_PAGE {
@@ -300,9 +292,8 @@ impl ISPDevice {
300292
self.init_read(start_addr).await?;
301293

302294
let mut result: Vec<u8> = Vec::with_capacity(num_page * page_size);
303-
let mut xfer_buf = vec![0; page_size + 2];
304295
for i in 0..num_page {
305-
self.read_page_with(&mut xfer_buf, &mut result).await?;
296+
self.read_page(&mut result).await?;
306297
progress(i + 1, num_page);
307298
}
308299
Ok(result)
@@ -323,9 +314,8 @@ impl ISPDevice {
323314

324315
self.init_write(start_addr).await?;
325316

326-
let mut xfer_buf = vec![0; page_size + 2];
327317
for i in 0..num_page {
328-
self.write_page_with(&mut xfer_buf, &buffer[(i * page_size)..((i + 1) * page_size)])
318+
self.write_page(&buffer[(i * page_size)..((i + 1) * page_size)])
329319
.await?;
330320
progress(i + 1, num_page);
331321
}

‎src/util.rs‎

Lines changed: 2 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,3 @@
1-
use std::fmt::Write;
2-
31
use crate::DeviceSpec;
42
use hidra::HidError;
53
use thiserror::Error;
@@ -149,14 +147,8 @@ pub fn convert_to_isp_payload(
149147
}
150148

151149
pub fn to_hex_string(bytes: &[u8]) -> String {
152-
let mut s = String::with_capacity(bytes.len() * 3);
153-
for (i, b) in bytes.iter().enumerate() {
154-
if i > 0 {
155-
s.push(' ');
156-
}
157-
let _ = write!(s, "{b:02X}");
158-
}
159-
s
150+
let strs: Vec<String> = bytes.iter().map(|b| format!("{b:02X}")).collect();
151+
strs.join(" ")
160152
}
161153

162154
pub fn is_expected_error(err: &HidError) -> bool {

0 commit comments

Comments
 (0)