Struct netcdf3::Dimension

pub struct Dimension { /* fields omitted */ }

NetCDF-3 dimension

Dimension instances are managed by a DataSet.

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

Examples

Create and read 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.get_dim_size(DIM_NAME_1));
assert_eq!(Some(DimensionType::UnlimitedSize),  data_set.get_dim_type(DIM_NAME_1));
assert_eq!(true,                                data_set.has_dim(DIM_NAME_2));
assert_eq!(Some(DIM_SIZE_2),                    data_set.get_dim_size(DIM_NAME_2));
assert_eq!(Some(DimensionType::FixedSize),      data_set.get_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.get_dim_size(DIM_NAME_1));
assert_eq!(Some(DimensionType::FixedSize),  data_set.get_dim_type(DIM_NAME_1));
assert_eq!(false,                           data_set.has_dim(DIM_NAME_2));
assert_eq!(None,                            data_set.get_dim_size(DIM_NAME_2));
assert_eq!(None,                            data_set.get_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.get_dim_size(DIM_NAME_1));
assert_eq!(None,                            data_set.get_dim_type(DIM_NAME_1));
assert_eq!(true,                            data_set.has_dim(DIM_NAME_2));
assert_eq!(Some(DIM_SIZE),                  data_set.get_dim_size(DIM_NAME_2));
assert_eq!(Some(DimensionType::FixedSize),  data_set.get_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.get_dim_size(DIM_NAME));
assert_eq!(Some(DimensionType::UnlimitedSize),  data_set.get_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.get_dim_size(DIM_NAME));
assert_eq!(None,    data_set.get_dim_type(DIM_NAME));

Methods

impl Dimension

pub fn name(&self) -> String

Returns the name of the NetCDF-3 dimension.

pub fn size(&self) -> usize

Returns the size of the NetCDF-3 dimension.

pub fn dim_type(&self) -> DimensionType

Returns the dimension type (fixed size ou unlimited size) of the NetCDF-3 dimension.

pub fn is_unlimited(&self) -> bool

Returns true if the dimension is a unlimited size dimension, otherwise return false.

pub fn is_fixed(&self) -> bool

Returns true if the dimension is a fixed size dimension, otherwise return false.

Trait Implementations

impl Clone for Dimension

fn clone(&self) -> Dimension

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dimension

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

Formats the value using the given formatter.

impl Eq for Dimension

impl PartialEq<Dimension> for Dimension

fn eq(&self, other: &Dimension) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Dimension) -> bool

This method tests for !=.

impl StructuralEq for Dimension

impl StructuralPartialEq for Dimension