gxci/hal/
config.rs

1//! Set of Get some values
2
3use crate::hal::base::gxi_check;
4use crate::hal::check::check_gx_status;
5use crate::hal::device::gxi_get_device_handle;
6use crate::raw::gx_enum::{GX_FEATURE_ID, GX_FEATURE_TYPE};
7use crate::raw::gx_interface::GXInterface;
8use crate::raw::gx_struct::{GX_ENUM_DESCRIPTION, GX_INT_RANGE, GX_FLOAT_RANGE};
9use crate::error::{Error, ErrorKind, Result};
10use crate::utils::matching::match_feature_type;
11use crate::utils::extract::{extract_n_value,extract_sz_symbolic};
12use std::ffi::CString;
13
14
15//----------------------------------------------------------
16//---------------HAL Functions---------------------------
17//----------------------------------------------------------
18
19// 用这种方法非常简洁的解决，得益于Any和Box了
20#[cfg(feature = "solo")]
21pub fn gxi_get_feature_value<T>(feature_id: GX_FEATURE_ID) -> Result<T>
22where
23    T: std::any::Any + std::fmt::Debug + Clone,
24{
25    let feature_type = match_feature_type(feature_id);
26    let value: Box<dyn std::any::Any> = match feature_type {
27        GX_FEATURE_TYPE::GX_FEATURE_INT => Box::new(gxi_get_int(feature_id)?),
28        GX_FEATURE_TYPE::GX_FEATURE_FLOAT => Box::new(gxi_get_float(feature_id)?),
29        GX_FEATURE_TYPE::GX_FEATURE_ENUM => Box::new(gxi_get_enum(feature_id)?),
30        GX_FEATURE_TYPE::GX_FEATURE_BOOL => Box::new(gxi_get_bool(feature_id)?),
31        GX_FEATURE_TYPE::GX_FEATURE_STRING => Box::new(gxi_get_string(feature_id)?),
32        GX_FEATURE_TYPE::GX_FEATURE_BUFFER => Box::new(gxi_get_buffer(feature_id)?),
33        _ => return Err(Error::new(ErrorKind::InvalidFeatureType("Invalid feature type.".to_string()))),
34    };
35
36    if let Some(result) = value.downcast_ref::<T>() {
37        Ok(result.clone())
38    } else {
39        Err(Error::new(ErrorKind::InvalidFeatureType(format!("Expected {}.", std::any::type_name::<T>()))))
40    }
41}
42
43#[cfg(feature = "solo")]
44pub fn gxi_set_feature_value(feature_id: GX_FEATURE_ID, value: &dyn std::any::Any) -> Result<()> {
45    let feature_type = match_feature_type(feature_id);
46    match feature_type {
47        GX_FEATURE_TYPE::GX_FEATURE_INT => {
48            if let Some(int_value) = value.downcast_ref::<i64>() {
49                gxi_set_int(feature_id, *int_value)
50            } else {
51                Err(Error::new(ErrorKind::InvalidFeatureType("Expected i64.".to_string())))
52            }
53        },
54        GX_FEATURE_TYPE::GX_FEATURE_FLOAT => {
55            if let Some(float_value) = value.downcast_ref::<f64>() {
56                gxi_set_float(feature_id, *float_value)
57            } else {
58                Err(Error::new(ErrorKind::InvalidFeatureType("Expected f64.".to_string())))
59            }
60        },
61        GX_FEATURE_TYPE::GX_FEATURE_ENUM => {
62            if let Some(enum_value) = value.downcast_ref::<i64>() {
63
64                gxi_set_enum(feature_id, *enum_value)
65            } else {
66                Err(Error::new(ErrorKind::InvalidFeatureType("Expected i64 enum.".to_string())))
67            }
68        },
69        GX_FEATURE_TYPE::GX_FEATURE_BOOL => {
70            if let Some(bool_value) = value.downcast_ref::<bool>() {
71                gxi_set_bool(feature_id, *bool_value)
72            } else {
73                Err(Error::new(ErrorKind::InvalidFeatureType("Expected bool.".to_string())))
74            }
75        },
76        GX_FEATURE_TYPE::GX_FEATURE_STRING => {
77            if let Some(string_value) = value.downcast_ref::<String>() {
78                gxi_set_string(feature_id, string_value)
79            } else {
80                Err(Error::new(ErrorKind::InvalidFeatureType("Expected String.".to_string())))
81            }
82        },
83        GX_FEATURE_TYPE::GX_FEATURE_BUFFER => {
84            if let Some(buffer_value) = value.downcast_ref::<Vec<u8>>() {
85                gxi_set_buffer(feature_id, buffer_value)
86            } else {
87                Err(Error::new(ErrorKind::InvalidFeatureType("Expected Vec<u8>.".to_string())))
88            }
89        },
90        _ => Err(Error::new(ErrorKind::InvalidFeatureType("Invalid feature type.".to_string())))
91    }
92}
93
94#[cfg(feature = "solo")]
95#[derive(Debug, Clone)]
96pub struct GxiEnumDescription {
97    pub n_value: i64,
98    pub sz_symbolic: String,
99    pub feature_id: GX_FEATURE_ID,
100}
101
102//----------------------------------------------------------
103//---------------Raw-Warpper Functions---------------------------
104//----------------------------------------------------------
105
106#[cfg(feature = "solo")]
107pub fn gxi_get_feature_name(feature_id: GX_FEATURE_ID) -> Result<String> {
108    let gxi_device = gxi_get_device_handle()?;
109    let mut buffer_size:usize = 8;
110    let mut feature_name = vec![0u8; buffer_size];
111    let status = gxi_check(|gxi| gxi.gx_get_feature_name(gxi_device, feature_id, feature_name.as_mut_ptr() as *mut i8, &mut buffer_size))?; 
112    // 这里的feature_name.as_mut_ptr() as *mut i8是将feature_name的地址转换成i8类型的指钋
113
114    check_gx_status(status)?;
115    println!("Successfully get feature name.");
116    Ok(String::from_utf8(feature_name).unwrap())
117}
118
119#[cfg(feature = "solo")]
120pub fn gxi_get_int_range(feature_id: GX_FEATURE_ID) -> Result<GX_INT_RANGE> {
121    let gxi_device = gxi_get_device_handle()?;
122    let mut int_range = GX_INT_RANGE::new();
123    let status = gxi_check(|gxi| gxi.gx_get_int_range(gxi_device, feature_id, &mut int_range))?;
124
125    check_gx_status(status)?;
126    println!("Successfully get int range.");
127    Ok(int_range)
128}
129
130#[cfg(feature = "solo")]
131pub fn gxi_get_int(feature_id: GX_FEATURE_ID) -> Result<i64> {
132    let gxi_device = gxi_get_device_handle()?;
133    let mut int_value = 0;
134    let status = gxi_check(|gxi| gxi.gx_get_int(gxi_device, feature_id, &mut int_value))?;
135
136    check_gx_status(status)?;
137    println!("Successfully get int value.");
138    Ok(int_value)
139}
140
141#[cfg(feature = "solo")]
142pub fn gxi_set_int(feature_id: GX_FEATURE_ID, int_value:i64) -> Result<()> {
143    let gxi_device = gxi_get_device_handle()?;
144    let status = gxi_check(|gxi| gxi.gx_set_int(gxi_device, feature_id, int_value))?;
145
146    check_gx_status(status)?;
147    println!("Successfully set int value.");
148    Ok(())
149}
150
151#[cfg(feature = "solo")]
152pub fn gxi_get_float_range(feature_id: GX_FEATURE_ID) -> Result<GX_FLOAT_RANGE> {
153    let gxi_device = gxi_get_device_handle()?;
154    let mut float_range = GX_FLOAT_RANGE::new();
155    let status = gxi_check(|gxi| gxi.gx_get_float_range(gxi_device, feature_id, &mut float_range))?;
156
157    check_gx_status(status)?;
158    println!("Successfully get float range.");
159    Ok(float_range)
160}
161
162#[cfg(feature = "solo")]
163pub fn gxi_get_float(feature_id: GX_FEATURE_ID) -> Result<f64> {
164    let gxi_device = gxi_get_device_handle()?;
165    let mut float_value = 0.0;
166    let status = gxi_check(|gxi| gxi.gx_get_float(gxi_device, feature_id, &mut float_value))?;
167
168    check_gx_status(status)?;
169    println!("Successfully get float value.");
170    Ok(float_value)
171}
172
173#[cfg(feature = "solo")]
174pub fn gxi_set_float(feature_id: GX_FEATURE_ID, float_value:f64) -> Result<()> {
175    let gxi_device = gxi_get_device_handle()?;
176    let status = gxi_check(|gxi| gxi.gx_set_float(gxi_device, feature_id, float_value))?;
177
178    check_gx_status(status)?;
179    println!("Successfully set float value.");
180    Ok(())
181}
182
183#[cfg(feature = "solo")]
184pub fn gxi_get_enum_entry_nums(feature_id: GX_FEATURE_ID) -> Result<u32> {
185    let gxi_device = gxi_get_device_handle()?;
186    let mut enum_entry_nums = 0;
187    let status = gxi_check(|gxi| gxi.gx_get_enum_entry_nums(gxi_device, feature_id, &mut enum_entry_nums))?;
188
189    check_gx_status(status)?;
190    println!("Successfully get enum entry number.");
191    Ok(enum_entry_nums)
192}
193
194#[cfg(feature = "solo")]
195pub fn gxi_get_enum_description(feature_id: GX_FEATURE_ID) -> Result<Vec<GxiEnumDescription>> {
196    let gxi_device = gxi_get_device_handle()?;
197    let enum_entry_nums = gxi_get_enum_entry_nums(feature_id)?;
198
199    let mut enum_descriptions: Vec<GX_ENUM_DESCRIPTION> =
200        vec![GX_ENUM_DESCRIPTION::new(); enum_entry_nums as usize];
201    let enum_descriptions_ptr: *mut GX_ENUM_DESCRIPTION = enum_descriptions.as_mut_ptr();
202    let mut buffer_size :usize = enum_entry_nums as usize * core::mem::size_of::<GX_ENUM_DESCRIPTION>() as usize + 1usize;
203
204    let status = gxi_check(|gxi| gxi.gx_get_enum_description(gxi_device, feature_id, enum_descriptions_ptr, &mut buffer_size))?;
205
206    let mut gxi_enum_descriptions: Vec<GxiEnumDescription> = Vec::new();
207
208    for i in 0..enum_entry_nums {
209        let n_value = extract_n_value(enum_descriptions[i as usize]);
210        let sz_symbolic = extract_sz_symbolic(enum_descriptions[i as usize]);
211        gxi_enum_descriptions.push(GxiEnumDescription {
212            n_value,
213            sz_symbolic,
214            feature_id,
215        });
216    }
217
218    check_gx_status(status)?;
219    println!("Successfully get enum description.");
220    Ok(gxi_enum_descriptions)
221}
222
223#[cfg(feature = "solo")]
224pub fn gxi_get_enum(feature_id: GX_FEATURE_ID) -> Result<i64> {
225    let gxi_device = gxi_get_device_handle()?;
226    let mut enum_value = 0;
227    let status = gxi_check(|gxi| gxi.gx_get_enum(gxi_device, feature_id, &mut enum_value))?;
228
229    check_gx_status(status)?;
230    println!("Successfully get enum value.");
231    Ok(enum_value)
232}
233
234
235#[cfg(feature = "solo")]
236pub fn gxi_set_enum(feature_id: GX_FEATURE_ID, enum_value:i64) -> Result<()> {
237    let gxi_device = gxi_get_device_handle()?;
238    let status = gxi_check(|gxi| gxi.gx_set_enum(gxi_device, feature_id, enum_value))?;
239
240    check_gx_status(status)?;
241    println!("Successfully set enum value.");
242    Ok(())
243}
244
245
246#[cfg(feature = "solo")]
247pub fn gxi_get_bool(feature_id: GX_FEATURE_ID) -> Result<bool> {
248    let gxi_device = gxi_get_device_handle()?;
249    let mut bool_value = false;
250    let status = gxi_check(|gxi| gxi.gx_get_bool(gxi_device, feature_id, &mut bool_value))?;
251
252    check_gx_status(status)?;
253    println!("Successfully get bool value.");
254    Ok(bool_value)
255}
256
257#[cfg(feature = "solo")]
258pub fn gxi_set_bool(feature_id: GX_FEATURE_ID, bool_value:bool) -> Result<()> {
259    let gxi_device = gxi_get_device_handle()?;
260    let status = gxi_check(|gxi| gxi.gx_set_bool(gxi_device, feature_id, bool_value))?;
261
262    check_gx_status(status)?;
263    println!("Successfully set bool value.");
264    Ok(())
265}
266
267
268#[cfg(feature = "solo")]
269pub fn gxi_get_string_length(feature_id: GX_FEATURE_ID) -> Result<usize> {
270    let gxi_device = gxi_get_device_handle()?;
271    let mut string_length = 0;
272    let status = gxi_check(|gxi| gxi.gx_get_string_length(gxi_device, feature_id, &mut string_length))?;
273
274    check_gx_status(status)?;
275    println!("Successfully get string length.");
276    Ok(string_length)
277}
278
279#[cfg(feature = "solo")]
280pub fn gxi_get_string_max_length(feature_id: GX_FEATURE_ID) -> Result<usize> {
281    let gxi_device = gxi_get_device_handle()?;
282    let mut string_max_length = 0;
283    let status = gxi_check(|gxi| gxi.gx_get_string_max_length(gxi_device, feature_id, &mut string_max_length))?;
284
285    check_gx_status(status)?;
286    println!("Successfully get string max length.");
287    Ok(string_max_length)
288}
289
290#[cfg(feature = "solo")]
291pub fn gxi_get_string(feature_id: GX_FEATURE_ID) -> Result<String> {
292    let gxi_device = gxi_get_device_handle()?;
293    let mut buffer_size:usize = gxi_get_string_length(feature_id)?;
294    let mut string = vec![0u8; buffer_size];
295    let status = gxi_check(|gxi| gxi.gx_get_string(gxi_device, feature_id, string.as_mut_ptr() as *mut i8, &mut buffer_size))?;
296
297    check_gx_status(status)?;
298    println!("Successfully get string.");
299    Ok(String::from_utf8(string).unwrap())
300}
301
302#[cfg(feature = "solo")]
303pub fn gxi_set_string(feature_id: GX_FEATURE_ID, string_value:&str) -> Result<()> {
304    let gxi_device = gxi_get_device_handle()?;
305
306    // &str -> CString -> *mut i8
307    let c_string = CString::new(string_value)?;
308    let c_ptr: *mut i8 = c_string.as_ptr() as *mut i8;
309
310    let status = gxi_check(|gxi| gxi.gx_set_string(gxi_device, feature_id, c_ptr))?;
311
312    check_gx_status(status)?;
313    println!("Successfully set string.");
314    Ok(())
315}
316
317
318#[cfg(feature = "solo")]
319pub fn gxi_get_buffer_length(feature_id: GX_FEATURE_ID) -> Result<usize> {
320    let gxi_device = gxi_get_device_handle()?;
321    let mut buffer_length = 0;
322    let status = gxi_check(|gxi| gxi.gx_get_buffer_length(gxi_device, feature_id, &mut buffer_length))?;
323
324    check_gx_status(status)?;
325    println!("Successfully get buffer length.");
326    Ok(buffer_length)
327}
328
329
330#[cfg(feature = "solo")]
331pub fn gxi_get_buffer(feature_id: GX_FEATURE_ID) -> Result<Vec<u8>> {
332    let gxi_device = gxi_get_device_handle()?;
333    let mut buffer_size = gxi_get_buffer_length(feature_id)?;
334    let mut buffer = vec![0u8; buffer_size];
335    let status = gxi_check(|gxi| gxi.gx_get_buffer(gxi_device, feature_id, buffer.as_mut_ptr(), &mut buffer_size))?;
336
337    check_gx_status(status)?;
338    println!("Successfully get buffer.");
339    Ok(buffer)
340}
341
342
343#[cfg(feature = "solo")]
344pub fn gxi_set_buffer(feature_id: GX_FEATURE_ID, buffer:&[u8]) -> Result<()> {
345    let gxi_device = gxi_get_device_handle()?;
346    let buffer_size = buffer.len();
347    let status = gxi_check(|gxi| gxi.gx_set_buffer(gxi_device, feature_id, buffer.as_ptr(), buffer_size))?;
348
349    check_gx_status(status)?;
350    println!("Successfully set buffer.");
351    Ok(())
352}
gxci/hal/config.rs

gxci/hal/
config.rs
