[−][src]Struct netcdf3::Attribute

pub struct Attribute { /* fields omitted */ }

NetCDF-3 attribute

Attribute instances are managed by a DataSet.

DataSets allow to create, read, remove and rename Attributess.

Examples

Global attributes

Create and read a global attribute

use netcdf3::{DataSet, Attribute, DataType};

const GLOBAL_ATTR_NAME: &str = "attr_1";
const GLOBAL_ATTR_DATA: [i32; 3] = [1, 2, 3];
const GLOBAL_ATTR_LEN: usize = GLOBAL_ATTR_DATA.len();

// First create the data set
let mut data_set = DataSet::new();

// Create a `i32` global attribute
data_set.add_global_attr_i32(GLOBAL_ATTR_NAME, GLOBAL_ATTR_DATA.to_vec()).unwrap();

assert_eq!(1,                       data_set.num_global_attrs());
assert_eq!(true,                    data_set.has_global_attr(GLOBAL_ATTR_NAME));
assert_eq!(Some(GLOBAL_ATTR_LEN),   data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
assert_eq!(Some(DataType::I32),     data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));

// Get the `i32` stored values through the data set
assert_eq!(None,                        data_set.get_global_attr_i8(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_u8(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_i16(GLOBAL_ATTR_NAME));
assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_f32(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_f64(GLOBAL_ATTR_NAME));

// Or through a reference to the global attribute
let global_attr: &Attribute = data_set.get_global_attr(GLOBAL_ATTR_NAME).unwrap();

assert_eq!(GLOBAL_ATTR_NAME,    global_attr.name());
assert_eq!(GLOBAL_ATTR_LEN,     global_attr.len());
assert_eq!(DataType::I32,       global_attr.data_type());

assert_eq!(None,                        global_attr.get_i8());
assert_eq!(None,                        global_attr.get_u8());
assert_eq!(None,                        global_attr.get_i16());
assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), global_attr.get_i32());
assert_eq!(None,                        global_attr.get_f32());
assert_eq!(None,                        global_attr.get_f64());

Rename a global attribute

use netcdf3::{DataSet, DataType};

const GLOBAL_ATTR_NAME_1: &str = "attr_1";
const GLOBAL_ATTR_NAME_2: &str = "attr_2";
const GLOBAL_ATTR_DATA: [i32; 3] = [1, 2, 3];
const GLOBAL_ATTR_LEN: usize = GLOBAL_ATTR_DATA.len();


// Create a data set
let mut data_set: DataSet = DataSet::new();
// Create a `i32` variable attribute
data_set.add_global_attr_i32(GLOBAL_ATTR_NAME_1, GLOBAL_ATTR_DATA.to_vec()).unwrap();

assert_eq!(1,                       data_set.num_global_attrs());
assert_eq!(true,                    data_set.has_global_attr(GLOBAL_ATTR_NAME_1));
assert_eq!(Some(GLOBAL_ATTR_LEN),   data_set.get_global_attr_len(GLOBAL_ATTR_NAME_1));
assert_eq!(Some(DataType::I32),     data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_1));
assert_eq!(false,                   data_set.has_global_attr(GLOBAL_ATTR_NAME_2));
assert_eq!(None,                    data_set.get_global_attr_len(GLOBAL_ATTR_NAME_2));
assert_eq!(None,                    data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_2));

assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_1));
assert_eq!(None,                        data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_2));

data_set.rename_global_attr(GLOBAL_ATTR_NAME_1, GLOBAL_ATTR_NAME_2).unwrap();

assert_eq!(1,                       data_set.num_global_attrs());
assert_eq!(false,                   data_set.has_global_attr(GLOBAL_ATTR_NAME_1));
assert_eq!(None,                    data_set.get_global_attr_len(GLOBAL_ATTR_NAME_1));
assert_eq!(None,                    data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_1));
assert_eq!(true,                    data_set.has_global_attr(GLOBAL_ATTR_NAME_2));
assert_eq!(Some(GLOBAL_ATTR_LEN),   data_set.get_global_attr_len(GLOBAL_ATTR_NAME_2));
assert_eq!(Some(DataType::I32),     data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME_2));

assert_eq!(None,                        data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_1));
assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME_2));

Remove a global attribute

use netcdf3::{DataSet, DataType};

const GLOBAL_ATTR_NAME: &str = "attr_1";
const GLOBAL_ATTR_DATA: [i32; 3] = [1, 2, 3];
const GLOBAL_ATTR_DATA_LEN: usize = GLOBAL_ATTR_DATA.len();


// Create a data set
let mut data_set: DataSet = DataSet::new();
// Create a `i32` variable attribute
data_set.add_global_attr_i32(GLOBAL_ATTR_NAME, GLOBAL_ATTR_DATA.to_vec()).unwrap();

assert_eq!(1,                           data_set.num_global_attrs());
assert_eq!(true,                        data_set.has_global_attr(GLOBAL_ATTR_NAME));
assert_eq!(Some(GLOBAL_ATTR_DATA_LEN),  data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
assert_eq!(Some(DataType::I32),         data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));
assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));

data_set.remove_global_attr(GLOBAL_ATTR_NAME).unwrap();

assert_eq!(0,      data_set.num_global_attrs());
assert_eq!(false,  data_set.has_global_attr(GLOBAL_ATTR_NAME));
assert_eq!(None,   data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
assert_eq!(None,   data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));
assert_eq!(None,   data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));

Variable attributes

Create and read a variable attribute

use netcdf3::{DataSet, Variable, Attribute, DataType, InvalidDataSet};

const VAR_NAME: &str = "var_1";
const VAR_ATTR_NAME: &str = "attr_1";
const VAR_ATTR_DATA: [i32; 3] = [1, 2, 3];
const VAR_ATTR_DATA_LEN: usize = VAR_ATTR_DATA.len();

// Create a data set
let mut data_set = DataSet::new();
// Create a `i8` variable
data_set.add_var_i8::<&str>(VAR_NAME, &vec![]).unwrap();
// Create a `i32` variable attribute
data_set.add_var_attr_i32(VAR_NAME, VAR_ATTR_NAME, VAR_ATTR_DATA.to_vec()).unwrap();

assert_eq!(Some(1),             data_set.num_var_attrs(VAR_NAME));
assert_eq!(Some(true),          data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(Some(VAR_ATTR_DATA_LEN),  data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(Some(DataType::I32), data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME));

// Get the `i32` stored values through the data set
assert_eq!(None,                        data_set.get_var_attr_i8(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,                        data_set.get_var_attr_u8(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,                        data_set.get_var_attr_i16(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(Some(&VAR_ATTR_DATA[..]),    data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,                        data_set.get_var_attr_f32(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,                        data_set.get_var_attr_f64(VAR_NAME, VAR_ATTR_NAME));

// Or through a reference to the variable attribute
let var_attr: &Attribute = data_set.get_var_attr(VAR_NAME, VAR_ATTR_NAME).unwrap();

assert_eq!(VAR_ATTR_NAME,               var_attr.name());
assert_eq!(VAR_ATTR_DATA_LEN,           var_attr.len());
assert_eq!(DataType::I32,               var_attr.data_type());

assert_eq!(None,                        var_attr.get_i8());
assert_eq!(None,                        var_attr.get_u8());
assert_eq!(None,                        var_attr.get_i16());
assert_eq!(Some(&VAR_ATTR_DATA[..]),    var_attr.get_i32());
assert_eq!(None,                        var_attr.get_f32());
assert_eq!(None,                        var_attr.get_f64());

Rename a variable attribute

use netcdf3::{DataSet, DataType};

const VAR_NAME: &'static  str = "var_1";
const VAR_ATTR_NAME_1: &str = "attr_1";
const VAR_ATTR_NAME_2: &str = "attr_2";
const VAR_ATTR_DATA: [i32; 3] = [1, 2, 3];
const VAR_ATTR_DATA_LEN: usize = VAR_ATTR_DATA.len();

// Create a data set
let mut data_set = DataSet::new();
// Create a `i8` variable
data_set.add_var_i8::<&str>(VAR_NAME, &vec![]).unwrap();
// Create a `i32` variable attribute
data_set.add_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_1, VAR_ATTR_DATA.to_vec()).unwrap();

assert_eq!(Some(1),                     data_set.num_var_attrs(VAR_NAME));
assert_eq!(Some(true),                  data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(Some(VAR_ATTR_DATA_LEN),     data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(Some(&VAR_ATTR_DATA[..]),    data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(Some(DataType::I32),         data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(Some(false),                 data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_2));
assert_eq!(None,                        data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_2));
assert_eq!(None,                        data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_2));
assert_eq!(None,                        data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_2));

// Rename the variable
data_set.rename_var_attr(VAR_NAME, VAR_ATTR_NAME_1, VAR_ATTR_NAME_2).unwrap();

assert_eq!(Some(1),                     data_set.num_var_attrs(VAR_NAME));
assert_eq!(Some(false),                 data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(None,                        data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(None,                        data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(None,                        data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_1));
assert_eq!(Some(true),                  data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME_2));
assert_eq!(Some(VAR_ATTR_DATA_LEN),     data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME_2));
assert_eq!(Some(&VAR_ATTR_DATA[..]),    data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME_2));
assert_eq!(Some(DataType::I32),         data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME_2));

Remove a variable attribute

use netcdf3::{DataSet, DataType};

const VAR_NAME: &'static  str = "var_1";
const VAR_ATTR_NAME: &str = "attr_1";
const VAR_ATTR_DATA: [i32; 3] = [1, 2, 3];
const VAR_ATTR_DATA_LEN: usize = VAR_ATTR_DATA.len();

// Create a data set
let mut data_set = DataSet::new();
// Create a `i8` variable
data_set.add_var_i8::<&str>(VAR_NAME, &vec![]).unwrap();
// Create a `i32` variable attribute
data_set.add_var_attr_i32(VAR_NAME, VAR_ATTR_NAME, VAR_ATTR_DATA.to_vec()).unwrap();

assert_eq!(Some(1),                     data_set.num_var_attrs(VAR_NAME));
assert_eq!(Some(true),                  data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(Some(VAR_ATTR_DATA_LEN),     data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(Some(DataType::I32),         data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(Some(&VAR_ATTR_DATA[..]),    data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME));

// Remove the variable
data_set.remove_var_attr(VAR_NAME, VAR_ATTR_NAME).unwrap();

assert_eq!(Some(0),     data_set.num_var_attrs(VAR_NAME));
assert_eq!(Some(false), data_set.has_var_attr(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,        data_set.get_var_attr_len(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,        data_set.get_var_attr_data_type(VAR_NAME, VAR_ATTR_NAME));
assert_eq!(None,        data_set.get_var_attr_i32(VAR_NAME, VAR_ATTR_NAME));

Methods

`impl Attribute`[src]

`pub fn name(&self) -> &str`[src]

Returns the name of the attribute.

`pub fn data_type(&self) -> DataType`[src]

Returns the NetCDF-3 data type of the attribute : i8, u8, ...

`pub fn len(&self) -> usize`[src]

Returns the number of elements (the length) of the attribute.

`pub fn get_i8(&self) -> Option<&[i8]>`[src]

Returns a reference of the i8 data or None of the attribute has not i8 data.

Example

use netcdf3::{DataSet, Attribute, DataType};

const GLOBAL_ATTR_NAME: &str = "attr_1";
const GLOBAL_ATTR_DATA: [i8; 3] = [1, 2, 3];
const GLOBAL_ATTR_DATA_LEN: usize = GLOBAL_ATTR_DATA.len();

// Create a data set and add a `i8` global attribute
// -------------------------------------------------
let mut data_set = DataSet::new();
data_set.add_global_attr_i8(GLOBAL_ATTR_NAME, GLOBAL_ATTR_DATA.to_vec()).unwrap();

// Get the stored `i8` data
// ------------------------
assert_eq!(true,                        data_set.has_global_attr(GLOBAL_ATTR_NAME));
assert_eq!(Some(GLOBAL_ATTR_DATA_LEN),  data_set.get_global_attr_len(GLOBAL_ATTR_NAME));
assert_eq!(Some(DataType::I8),          data_set.get_global_attr_data_type(GLOBAL_ATTR_NAME));

// Through the data set
assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), data_set.get_global_attr_i8(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_u8(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_i16(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_i32(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_f32(GLOBAL_ATTR_NAME));
assert_eq!(None,                        data_set.get_global_attr_f64(GLOBAL_ATTR_NAME));

// Or through a reference
let global_attr: &Attribute = data_set.get_global_attr(GLOBAL_ATTR_NAME).unwrap();

assert_eq!(Some(&GLOBAL_ATTR_DATA[..]), global_attr.get_i8());
assert_eq!(None,                        global_attr.get_u8());
assert_eq!(None,                        global_attr.get_i16());
assert_eq!(None,                        global_attr.get_i32());
assert_eq!(None,                        global_attr.get_f32());
assert_eq!(None,                        global_attr.get_f64());

`pub fn get_u8(&self) -> Option<&[u8]>`[src]

Returns a reference of the u8 data or None of the attribute has not u8 data (refer to the method get_i8).

`pub fn get_i16(&self) -> Option<&[i16]>`[src]

Returns a reference of the i16 data or None of the attribute has not i16 data (refer to the method get_i8).

`pub fn get_i32(&self) -> Option<&[i32]>`[src]

Returns a reference of the i32 data or None of the attribute has not i32 data (refer to the method get_i8).

`pub fn get_f32(&self) -> Option<&[f32]>`[src]

Returns a reference of the f32 data or None of the attribute has not f32 data (refer to the method get_i8).

`pub fn get_f64(&self) -> Option<&[f64]>`[src]

Returns a reference of the f64 data or None of the attribute has not f64 data (refer to the method get_i8).

Trait Implementations

`impl Clone for Attribute`[src]

`fn clone(&self) -> Attribute`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Debug for Attribute`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl PartialEq<Attribute> for Attribute`[src]

`fn eq(&self, other: &Attribute) -> bool`[src]

`fn ne(&self, other: &Attribute) -> bool`[src]

`impl StructuralPartialEq for Attribute`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Attribute`

`impl Send for Attribute`

`impl Sync for Attribute`

`impl Unpin for Attribute`

`impl UnwindSafe for Attribute`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

[−][src]Struct netcdf3::Attribute

Methods

impl Attribute[src]

pub fn name(&self) -> &str[src]

pub fn data_type(&self) -> DataType[src]

pub fn len(&self) -> usize[src]

pub fn get_i8(&self) -> Option<&[i8]>[src]

pub fn get_u8(&self) -> Option<&[u8]>[src]

pub fn get_i16(&self) -> Option<&[i16]>[src]

pub fn get_i32(&self) -> Option<&[i32]>[src]

pub fn get_f32(&self) -> Option<&[f32]>[src]

pub fn get_f64(&self) -> Option<&[f64]>[src]

Trait Implementations

impl Clone for Attribute[src]

fn clone(&self) -> Attribute[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl Debug for Attribute[src]

fn fmt(&self, f: &mut Formatter) -> Result[src]

impl PartialEq<Attribute> for Attribute[src]

fn eq(&self, other: &Attribute) -> bool[src]

fn ne(&self, other: &Attribute) -> bool[src]

impl StructuralPartialEq for Attribute[src]

Auto Trait Implementations

impl RefUnwindSafe for Attribute

impl Send for Attribute

impl Sync for Attribute

impl Unpin for Attribute

impl UnwindSafe for Attribute

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T> ToOwned for T where T: Clone, [src]

type Owned = T

fn to_owned(&self) -> T[src]

fn clone_into(&self, target: &mut T)[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]