netcdf3/data_set/attribute.rs
1mod tests;
2
3use crate::name_string::is_valid_name;
4use crate::data_vector::DataVector;
5use crate::DataType;
6
7/// NetCDF-3 attribute
8///
9/// `Attribute` instances are managed by the struct [`DataSet`](struct.DataSet.html).
10///
11/// `DataSet`s allow to create, get, remove and rename `Attribute`s.
12///
13/// # Examples
14///
15/// ## Global attributes
16///
17/// ### Create and get a global attribute
18///
19/// ```
20/// use netcdf3::{DataSet, Attribute, DataType};
21///
22/// const GLOBAL_ATTR_NAME: &str = "attr_1";
23/// const GLOBAL_ATTR_DATA: [i32; 3] = [1, 2, 3];
24/// const GLOBAL_ATTR_LEN: usize = GLOBAL_ATTR_DATA.len();
25///
26/// // First create the data set
27/// let mut data_set = DataSet::new();
28///
29/// // Create a `i32` global attribute
30/// data_set.add_global_attr_i32(GLOBAL_ATTR_NAME, GLOBAL_ATTR_DATA.to_vec()).unwrap();
31///
32/// assert_eq!(1, data_set.num_global_attrs());
33/// assert_eq!(true, data_set.has_global_attr(GLOBAL_ATTR_NAME));
34/// assert_eq!(Some(GLOBAL_ATTR_LEN), data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
35/// assert_eq!(Some(DataType::I32), data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));
36///
37/// // Get the `i32` stored values through the data set
38/// assert_eq!(None, data_set.get_global_attr_i8(GLOBAL_ATTR_NAME));
39/// assert_eq!(None, data_set.get_global_attr_u8(GLOBAL_ATTR_NAME));
40/// assert_eq!(None, data_set.get_global_attr_i16(GLOBAL_ATTR_NAME));
41/// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));
42/// assert_eq!(None, data_set.get_global_attr_f32(GLOBAL_ATTR_NAME));
43/// assert_eq!(None, data_set.get_global_attr_f64(GLOBAL_ATTR_NAME));
44///
45/// // Or through a reference to the global attribute
46/// let global_attr: &Attribute = data_set.get_global_attr(GLOBAL_ATTR_NAME).unwrap();
47///
48/// assert_eq!(GLOBAL_ATTR_NAME, global_attr.name());
49/// assert_eq!(GLOBAL_ATTR_LEN, global_attr.len());
50/// assert_eq!(DataType::I32, global_attr.data_type());
51///
52/// assert_eq!(None, global_attr.get_i8());
53/// assert_eq!(None, global_attr.get_u8());
54/// assert_eq!(None, global_attr.get_i16());
55/// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), global_attr.get_i32());
56/// assert_eq!(None, global_attr.get_f32());
57/// assert_eq!(None, global_attr.get_f64());
58/// ```
59///
60/// ### Rename a global attribute
61///
62/// ```
63/// use netcdf3::{DataSet, DataType};
64///
65/// const GLOBAL_ATTR_NAME_1: &str = "attr_1";
66/// const GLOBAL_ATTR_NAME_2: &str = "attr_2";
67/// const GLOBAL_ATTR_DATA: [i32; 3] = [1, 2, 3];
68/// const GLOBAL_ATTR_LEN: usize = GLOBAL_ATTR_DATA.len();
69///
70///
71/// // Create a data set
72/// let mut data_set: DataSet = DataSet::new();
73/// // Create a `i32` variable attribute
74/// data_set.add_global_attr_i32(GLOBAL_ATTR_NAME_1, GLOBAL_ATTR_DATA.to_vec()).unwrap();
75///
76/// assert_eq!(1, data_set.num_global_attrs());
77/// assert_eq!(true, data_set.has_global_attr(GLOBAL_ATTR_NAME_1));
78/// assert_eq!(Some(GLOBAL_ATTR_LEN), data_set.get_global_attr_len(GLOBAL_ATTR_NAME_1));
79/// assert_eq!(Some(DataType::I32), data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_1));
80/// assert_eq!(false, data_set.has_global_attr(GLOBAL_ATTR_NAME_2));
81/// assert_eq!(None, data_set.get_global_attr_len(GLOBAL_ATTR_NAME_2));
82/// assert_eq!(None, data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_2));
83///
84/// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_1));
85/// assert_eq!(None, data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_2));
86///
87/// // Rename the global attribute
88/// data_set.rename_global_attr(GLOBAL_ATTR_NAME_1, GLOBAL_ATTR_NAME_2).unwrap();
89///
90/// // The global attribute has been renamed
91/// assert_eq!(1, data_set.num_global_attrs());
92/// assert_eq!(false, data_set.has_global_attr(GLOBAL_ATTR_NAME_1));
93/// assert_eq!(None, data_set.get_global_attr_len(GLOBAL_ATTR_NAME_1));
94/// assert_eq!(None, data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_1));
95/// assert_eq!(true, data_set.has_global_attr(GLOBAL_ATTR_NAME_2));
96/// assert_eq!(Some(GLOBAL_ATTR_LEN), data_set.get_global_attr_len(GLOBAL_ATTR_NAME_2));
97/// assert_eq!(Some(DataType::I32), data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_2));
98///
99/// assert_eq!(None, data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_1));
100/// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_2));
101/// ```
102///
103/// ### Remove a global attribute
104///
105/// ```
106/// use netcdf3::{DataSet, DataType};
107///
108/// const GLOBAL_ATTR_NAME: &str = "attr_1";
109/// const GLOBAL_ATTR_DATA: [i32; 3] = [1, 2, 3];
110/// const GLOBAL_ATTR_DATA_LEN: usize = GLOBAL_ATTR_DATA.len();
111///
112///
113/// // Create a data set
114/// let mut data_set: DataSet = DataSet::new();
115/// // Create a `i32` variable attribute
116/// data_set.add_global_attr_i32(GLOBAL_ATTR_NAME, GLOBAL_ATTR_DATA.to_vec()).unwrap();
117///
118/// assert_eq!(1, data_set.num_global_attrs());
119/// assert_eq!(true, data_set.has_global_attr(GLOBAL_ATTR_NAME));
120/// assert_eq!(Some(GLOBAL_ATTR_DATA_LEN), data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
121/// assert_eq!(Some(DataType::I32), data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));
122/// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));
123///
124/// // Remove the global attribute
125/// data_set.remove_global_attr(GLOBAL_ATTR_NAME).unwrap();
126///
127/// // The global attribute has been removed
128/// assert_eq!(0, data_set.num_global_attrs());
129/// assert_eq!(false, data_set.has_global_attr(GLOBAL_ATTR_NAME));
130/// assert_eq!(None, data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
131/// assert_eq!(None, data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));
132/// assert_eq!(None, data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));
133/// ```
134///
135/// ## Variable attributes
136///
137/// ### Create and get a variable attribute
138///
139/// ```
140/// use netcdf3::{DataSet, Variable, Attribute, DataType, InvalidDataSet};
141///
142/// const VAR_NAME: &str = "var_1";
143/// const VAR_ATTR_NAME: &str = "attr_1";
144/// const VAR_ATTR_DATA: [i32; 3] = [1, 2, 3];
145/// const VAR_ATTR_DATA_LEN: usize = VAR_ATTR_DATA.len();
146///
147/// // Create a data set
148/// let mut data_set = DataSet::new();
149/// // Create a `i8` variable
150/// data_set.add_var_i8::<&str>(VAR_NAME, &vec![]).unwrap();
151/// // Create a `i32` variable attribute
152/// data_set.add_var_attr_i32(VAR_NAME, VAR_ATTR_NAME, VAR_ATTR_DATA.to_vec()).unwrap();
153///
154/// assert_eq!(Some(1), data_set.num_var_attrs(VAR_NAME));
155/// assert_eq!(Some(true), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME));
156/// assert_eq!(Some(VAR_ATTR_DATA_LEN), data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME));
157/// assert_eq!(Some(DataType::I32), data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME));
158///
159/// // Get the `i32` stored values through the data set
160/// assert_eq!(None, data_set.get_var_attr_i8(VAR_NAME, VAR_ATTR_NAME));
161/// assert_eq!(None, data_set.get_var_attr_u8(VAR_NAME, VAR_ATTR_NAME));
162/// assert_eq!(None, data_set.get_var_attr_i16(VAR_NAME, VAR_ATTR_NAME));
163/// assert_eq!(Some(&VAR_ATTR_DATA[..]), data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME));
164/// assert_eq!(None, data_set.get_var_attr_f32(VAR_NAME, VAR_ATTR_NAME));
165/// assert_eq!(None, data_set.get_var_attr_f64(VAR_NAME, VAR_ATTR_NAME));
166///
167/// // Or through a reference to the variable attribute
168/// let var_attr: &Attribute = data_set.get_var_attr(VAR_NAME, VAR_ATTR_NAME).unwrap();
169///
170/// assert_eq!(VAR_ATTR_NAME, var_attr.name());
171/// assert_eq!(VAR_ATTR_DATA_LEN, var_attr.len());
172/// assert_eq!(DataType::I32, var_attr.data_type());
173///
174/// assert_eq!(None, var_attr.get_i8());
175/// assert_eq!(None, var_attr.get_u8());
176/// assert_eq!(None, var_attr.get_i16());
177/// assert_eq!(Some(&VAR_ATTR_DATA[..]), var_attr.get_i32());
178/// assert_eq!(None, var_attr.get_f32());
179/// assert_eq!(None, var_attr.get_f64());
180/// ```
181///
182/// ### Rename a variable attribute
183///
184/// ```
185/// use netcdf3::{DataSet, DataType};
186///
187/// const VAR_NAME: &'static str = "var_1";
188/// const VAR_ATTR_NAME_1: &str = "attr_1";
189/// const VAR_ATTR_NAME_2: &str = "attr_2";
190/// const VAR_ATTR_DATA: [i32; 3] = [1, 2, 3];
191/// const VAR_ATTR_DATA_LEN: usize = VAR_ATTR_DATA.len();
192///
193/// // Create a data set
194/// let mut data_set = DataSet::new();
195/// // Create a `i8` variable
196/// data_set.add_var_i8::<&str>(VAR_NAME, &vec![]).unwrap();
197/// // Create a `i32` variable attribute
198/// data_set.add_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_1, VAR_ATTR_DATA.to_vec()).unwrap();
199///
200/// assert_eq!(Some(1), data_set.num_var_attrs(VAR_NAME));
201/// assert_eq!(Some(true), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_1));
202/// assert_eq!(Some(VAR_ATTR_DATA_LEN), data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_1));
203/// assert_eq!(Some(&VAR_ATTR_DATA[..]), data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_1));
204/// assert_eq!(Some(DataType::I32), data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_1));
205/// assert_eq!(Some(false), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_2));
206/// assert_eq!(None, data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_2));
207/// assert_eq!(None, data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_2));
208/// assert_eq!(None, data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_2));
209///
210/// // Rename the variable
211/// data_set.rename_var_attr(VAR_NAME, VAR_ATTR_NAME_1, VAR_ATTR_NAME_2).unwrap();
212///
213/// assert_eq!(Some(1), data_set.num_var_attrs(VAR_NAME));
214/// assert_eq!(Some(false), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_1));
215/// assert_eq!(None, data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_1));
216/// assert_eq!(None, data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_1));
217/// assert_eq!(None, data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_1));
218/// assert_eq!(Some(true), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_2));
219/// assert_eq!(Some(VAR_ATTR_DATA_LEN), data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_2));
220/// assert_eq!(Some(&VAR_ATTR_DATA[..]), data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_2));
221/// assert_eq!(Some(DataType::I32), data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_2));
222/// ```
223///
224/// ### Remove a variable attribute
225///
226/// ```
227/// use netcdf3::{DataSet, DataType};
228///
229/// const VAR_NAME: &'static str = "var_1";
230/// const VAR_ATTR_NAME: &str = "attr_1";
231/// const VAR_ATTR_DATA: [i32; 3] = [1, 2, 3];
232/// const VAR_ATTR_DATA_LEN: usize = VAR_ATTR_DATA.len();
233///
234/// // Create a data set
235/// let mut data_set = DataSet::new();
236/// // Create a `i8` variable
237/// data_set.add_var_i8::<&str>(VAR_NAME, &vec![]).unwrap();
238/// // Create a `i32` variable attribute
239/// data_set.add_var_attr_i32(VAR_NAME, VAR_ATTR_NAME, VAR_ATTR_DATA.to_vec()).unwrap();
240///
241/// assert_eq!(Some(1), data_set.num_var_attrs(VAR_NAME));
242/// assert_eq!(Some(true), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME));
243/// assert_eq!(Some(VAR_ATTR_DATA_LEN), data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME));
244/// assert_eq!(Some(DataType::I32), data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME));
245/// assert_eq!(Some(&VAR_ATTR_DATA[..]), data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME));
246///
247/// // Remove the variable
248/// data_set.remove_var_attr(VAR_NAME, VAR_ATTR_NAME).unwrap();
249///
250/// assert_eq!(Some(0), data_set.num_var_attrs(VAR_NAME));
251/// assert_eq!(Some(false), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME));
252/// assert_eq!(None, data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME));
253/// assert_eq!(None, data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME));
254/// assert_eq!(None, data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME));
255/// ```
256///
257
258#[derive(Debug, Clone, PartialEq)]
259pub struct Attribute {
260 pub(crate) name: String,
261 pub(crate) data: DataVector,
262}
263
264impl Attribute {
265 /// Creates a new attribute from a `DataVector`.
266 pub(crate) fn new(name: &str, data: DataVector) -> Result<Attribute, String> {
267 Attribute::check_attr_name(name)?;
268 Ok(Attribute {
269 name: name.to_string(),
270 data: data,
271 })
272 }
273 /// Creates a new attribute containing i8 data.
274 pub(in crate::data_set) fn new_i8(name: &str, data: Vec<i8>) -> Result<Attribute, String> {
275 let data = DataVector::I8(data);
276 Attribute::new(name, data)
277 }
278
279 /// Creates a new attribute containing *u8* data.
280 pub(in crate::data_set) fn new_u8(name: &str, data: Vec<u8>) -> Result<Attribute, String> {
281 let data = DataVector::U8(data);
282 Attribute::new(name, data)
283 }
284
285 /// Create a new attribute containing *i16* data.
286 pub(in crate::data_set) fn new_i16(name: &str, data: Vec<i16>) -> Result<Attribute, String> {
287 let data = DataVector::I16(data);
288 Attribute::new(name, data)
289 }
290
291 /// Creates a new attribute containing *i32* data.
292 pub(crate) fn new_i32(name: &str, data: Vec<i32>) -> Result<Attribute, String> {
293 let data = DataVector::I32(data);
294 Attribute::new(name, data)
295 }
296
297 /// Creates a new attribute containing *f32* data.
298 pub(crate) fn new_f32(name: &str, data: Vec<f32>) -> Result<Attribute, String> {
299 let data = DataVector::F32(data);
300 Attribute::new(name, data)
301 }
302
303 /// Creates a new attribute containing *f64* data.
304 pub(crate) fn new_f64(name: &str, data: Vec<f64>) -> Result<Attribute, String> {
305 let data = DataVector::F64(data);
306 Attribute::new(name, data)
307 }
308
309 /// Returns the name of the attribute.
310 pub fn name(&self) -> &str {
311 &self.name
312 }
313 /// Returns the NetCDF-3 data type of the attribute : *i8*, *u8*, ...
314 pub fn data_type(&self) -> DataType {
315 self.data.data_type()
316 }
317
318 /// Returns the number of elements (the length) of the attribute.
319 pub fn len(&self) -> usize {
320 self.data.len()
321 }
322
323 /// Returns a reference of the `i8` data or `None` of the attribute has not `i8` data.
324 ///
325 /// # Example
326 ///
327 /// ```
328 /// use netcdf3::{DataSet, Attribute, DataType};
329 ///
330 /// const GLOBAL_ATTR_NAME: &str = "attr_1";
331 /// const GLOBAL_ATTR_DATA: [i8; 3] = [1, 2, 3];
332 /// const GLOBAL_ATTR_DATA_LEN: usize = GLOBAL_ATTR_DATA.len();
333 ///
334 /// // Create a data set and add a `i8` global attribute
335 /// // -------------------------------------------------
336 /// let mut data_set = DataSet::new();
337 /// data_set.add_global_attr_i8(GLOBAL_ATTR_NAME, GLOBAL_ATTR_DATA.to_vec()).unwrap();
338 ///
339 /// // Get the stored `i8` data
340 /// // ------------------------
341 /// assert_eq!(true, data_set.has_global_attr(GLOBAL_ATTR_NAME));
342 /// assert_eq!(Some(GLOBAL_ATTR_DATA_LEN), data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
343 /// assert_eq!(Some(DataType::I8), data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));
344 ///
345 /// // Through the data set
346 /// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i8(GLOBAL_ATTR_NAME));
347 /// assert_eq!(None, data_set.get_global_attr_u8(GLOBAL_ATTR_NAME));
348 /// assert_eq!(None, data_set.get_global_attr_i16(GLOBAL_ATTR_NAME));
349 /// assert_eq!(None, data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));
350 /// assert_eq!(None, data_set.get_global_attr_f32(GLOBAL_ATTR_NAME));
351 /// assert_eq!(None, data_set.get_global_attr_f64(GLOBAL_ATTR_NAME));
352 ///
353 /// // Or through a reference
354 /// let global_attr: &Attribute = data_set.get_global_attr(GLOBAL_ATTR_NAME).unwrap();
355 ///
356 /// assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), global_attr.get_i8());
357 /// assert_eq!(None, global_attr.get_u8());
358 /// assert_eq!(None, global_attr.get_i16());
359 /// assert_eq!(None, global_attr.get_i32());
360 /// assert_eq!(None, global_attr.get_f32());
361 /// assert_eq!(None, global_attr.get_f64());
362 /// ```
363 pub fn get_i8(&self) -> Option<&[i8]> {
364 self.data.get_i8()
365 }
366
367 /// Returns a reference of the `u8` data or `None` if the attribute has not `u8` data (also see the method [get_i8](struct.Attribute.html#method.get_i8)).
368 pub fn get_u8(&self) -> Option<&[u8]> {
369 self.data.get_u8()
370 }
371
372 /// Returns the attribute data as a `String`.
373 ///
374 /// Returns `None` if the attribute is not a `u8` attribute, or of this `u8` attribute does not contain valid UTF-8 encoded bytes
375 /// (also see the method [get_i8](struct.Attribute.html#method.get_u8)).
376 ///
377 /// # Example
378 ///
379 /// ```
380 /// use netcdf3::{DataSet, Attribute, DataType};
381 ///
382 /// const UTF8_ATTR_NAME: &str = "utf8_attr";
383 /// const LATIN1_ATTR_NAME: &str = "latin1_attr";
384 ///
385 /// let data_set: DataSet = {
386 /// let mut data_set: DataSet = DataSet::new();
387 ///
388 /// let utf8_bytes: Vec<u8> = "café".as_bytes().to_vec(); // utf-8 encoding
389 /// data_set.add_global_attr_u8(UTF8_ATTR_NAME, utf8_bytes).unwrap();
390 ///
391 /// let latin1_bytes: Vec<u8> = vec![b'c', b'a', b'f', b'\xe9']; // latin-1 encoding
392 /// data_set.add_global_attr_u8(LATIN1_ATTR_NAME, latin1_bytes).unwrap();
393 ///
394 /// data_set
395 /// };
396 ///
397 /// assert_eq!(2, data_set.num_global_attrs());
398 /// assert_eq!(true, data_set.has_global_attr(UTF8_ATTR_NAME));
399 /// {
400 /// let attr: &Attribute = data_set.get_global_attr(UTF8_ATTR_NAME).unwrap();
401 /// assert_eq!(DataType::U8, attr.data_type());
402 /// assert_eq!(Some(&[b'c', b'a', b'f', 0xc3, 0xa9][..]), attr.get_u8());
403 /// assert_eq!(Some(String::from("café")), attr.get_as_string());
404 /// }
405 /// assert_eq!(true, data_set.has_global_attr(LATIN1_ATTR_NAME));
406 /// {
407 /// let attr: &Attribute = data_set.get_global_attr(LATIN1_ATTR_NAME).unwrap();
408 /// assert_eq!(DataType::U8, attr.data_type());
409 /// assert_eq!(Some(&[b'c', b'a', b'f', b'\xe9'][..]), attr.get_u8());
410 /// assert_eq!(None, attr.get_as_string());
411 /// }
412 ///
413 ///
414 /// ```
415 pub fn get_as_string(&self) -> Option<String> {
416 self.data.get_as_string()
417 }
418
419 /// Returns a reference of the `i16` data or `None` if the attribute has not `i16` data (also see the method [get_i8](struct.Attribute.html#method.get_i8)).
420 pub fn get_i16(&self) -> Option<&[i16]> {
421 self.data.get_i16()
422 }
423
424 /// Returns a reference of the `i32` data or `None` if the attribute has not `i32` data (also see the method [get_i8](struct.Attribute.html#method.get_i8)).
425 pub fn get_i32(&self) -> Option<&[i32]> {
426 self.data.get_i32()
427 }
428
429 /// Returns a reference of the `f32` data or `None` if the attribute has not `f32` data (also see the method [get_i8](struct.Attribute.html#method.get_i8)).
430 pub fn get_f32(&self) -> Option<&[f32]> {
431 self.data.get_f32()
432 }
433
434 /// Returns a reference of the `f64` data or `None` if the attribute has not `f64` data (also see the method [get_i8](struct.Attribute.html#method.get_i8)).
435 pub fn get_f64(&self) -> Option<&[f64]> {
436 self.data.get_f64()
437 }
438
439 pub(crate) fn check_attr_name(attr_name: &str) -> Result<(), String> {
440 match is_valid_name(attr_name) {
441 true => Ok(()),
442 false => Err(attr_name.to_string()),
443 }
444 }
445}