Struct Dimension

Source

pub struct Dimension { /* private fields */ }

Expand description

NetCDF-3 dimension

Dimension instances are managed by the struct DataSet.

DataSets allow to create, get, remove and rename Dimensions.

§Examples

§Create and get fixed-size and unlimited-size dimensions

use std::rc::Rc;
use netcdf3::{DataSet, Dimension, DimensionType};

const DIM_NAME_1: &str = "dim_1";
const DIM_SIZE_1: usize = 10;
const DIM_NAME_2: &str = "dim_2";
const DIM_SIZE_2: usize = 20;

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

// Add one *fixed-size* dimensions and set the *unlimited-size* dimension
data_set.set_unlimited_dim(DIM_NAME_1, DIM_SIZE_1).unwrap();
data_set.add_fixed_dim(DIM_NAME_2, DIM_SIZE_2).unwrap();

// Read values throught the data set
assert_eq!(2,                                   data_set.num_dims());
assert_eq!(true,                                data_set.has_unlimited_dim());
assert_eq!(true,                                data_set.has_dim(DIM_NAME_1));
assert_eq!(Some(DIM_SIZE_1),                    data_set.dim_size(DIM_NAME_1));
assert_eq!(Some(DimensionType::UnlimitedSize),  data_set.dim_type(DIM_NAME_1));
assert_eq!(true,                                data_set.has_dim(DIM_NAME_2));
assert_eq!(Some(DIM_SIZE_2),                    data_set.dim_size(DIM_NAME_2));
assert_eq!(Some(DimensionType::FixedSize),      data_set.dim_type(DIM_NAME_2));

// Or through references of the dimensions
let dim_1: Rc<Dimension> = data_set.get_dim(DIM_NAME_1).unwrap();
assert_eq!(DIM_NAME_1,                          dim_1.name());
assert_eq!(DIM_SIZE_1,                          dim_1.size());
assert_eq!(true,                                dim_1.is_unlimited());
assert_eq!(false,                               dim_1.is_fixed());
assert_eq!(DimensionType::UnlimitedSize,        dim_1.dim_type());

let dim_2: Rc<Dimension> = data_set.get_dim(DIM_NAME_2).unwrap();
assert_eq!(DIM_NAME_2,                          dim_2.name());
assert_eq!(DIM_SIZE_2,                          dim_2.size());
assert_eq!(false,                               dim_2.is_unlimited());
assert_eq!(true,                                dim_2.is_fixed());
assert_eq!(DimensionType::FixedSize,            dim_2.dim_type());

§Rename a dimension

use netcdf3::{DataSet, DimensionType};

const DIM_NAME_1: &str = "dim_1";
const DIM_NAME_2: &str = "dim_2";
const DIM_SIZE: usize = 10;

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

// Add a *fixed-size* dimension
data_set.add_fixed_dim(DIM_NAME_1, DIM_SIZE).unwrap();

assert_eq!(1,                                   data_set.num_dims());
assert_eq!(false,                               data_set.has_unlimited_dim());
assert_eq!(true,                                data_set.has_dim(DIM_NAME_1));
assert_eq!(Some(DIM_SIZE),                      data_set.dim_size(DIM_NAME_1));
assert_eq!(Some(DimensionType::FixedSize),      data_set.dim_type(DIM_NAME_1));
assert_eq!(false,                               data_set.has_dim(DIM_NAME_2));
assert_eq!(None,                                data_set.dim_size(DIM_NAME_2));
assert_eq!(None,                                data_set.dim_type(DIM_NAME_2));

// Rename the *fixed-size* dimension
data_set.rename_dim(DIM_NAME_1, DIM_NAME_2).unwrap();

assert_eq!(1,                                   data_set.num_dims());
assert_eq!(false,                               data_set.has_unlimited_dim());
assert_eq!(false,                               data_set.has_dim(DIM_NAME_1));
assert_eq!(None,                                data_set.dim_size(DIM_NAME_1));
assert_eq!(None,                                data_set.dim_type(DIM_NAME_1));
assert_eq!(true,                                data_set.has_dim(DIM_NAME_2));
assert_eq!(Some(DIM_SIZE),                      data_set.dim_size(DIM_NAME_2));
assert_eq!(Some(DimensionType::FixedSize),      data_set.dim_type(DIM_NAME_2));

§Remove a dimension

use std::rc::Rc;
use netcdf3::{DataSet, Dimension, DimensionType};

const DIM_NAME: &str = "dim_1";
const DIM_SIZE: usize = 10;

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

// Set the *unlimited-size* dimension
data_set.set_unlimited_dim(DIM_NAME, DIM_SIZE).unwrap();

assert_eq!(1,                                   data_set.num_dims());
assert_eq!(true,                                data_set.has_unlimited_dim());
assert_eq!(true,                                data_set.has_dim(DIM_NAME));
assert_eq!(Some(DIM_SIZE),                      data_set.dim_size(DIM_NAME));
assert_eq!(Some(DimensionType::UnlimitedSize),  data_set.dim_type(DIM_NAME));

// Remove the *unlimited-size* dimension
let _removed_dim: Rc<Dimension> = data_set.remove_dim(DIM_NAME).unwrap();

assert_eq!(0,                                   data_set.num_dims());
assert_eq!(false,                               data_set.has_unlimited_dim());
assert_eq!(false,                               data_set.has_dim(DIM_NAME));
assert_eq!(None,                                data_set.dim_size(DIM_NAME));
assert_eq!(None,                                data_set.dim_type(DIM_NAME));