Enum raccoon::entry::DataEntry

pub enum DataEntry {
    Text(String),
    Integer(i32),
    UInteger(u32),
    Long(i64),
    ULong(u64),
    Float(f32),
    Double(f64),
    Boolean(bool),
    Character(char),
    NA,
}

A cell-like data entry. Note that DataEntry::Integer, DataEntry::UInteger, and DataEntry::Float, are only added for convenience. Due to how Rust enums are stored, using a DataEntry::Integer does not actually reduce the memory footprint versus DataEntry::Long.

See raccoon::entry for more details on memory efficiency.

Variants

Text(String)

A text entry.

Integer(i32)

An integer entry.

UInteger(u32)

An unsigned integer entry.

Long(i64)

A long entry.

ULong(u64)

An unsigned long entry.

Float(f32)

A floating point entry.

Double(f64)

A double precision floating point entry.

Boolean(bool)

A boolean entry.

Character(char)

A character entry.

NA

A missing or invalid entry.

Methods

impl DataEntry

pub fn internal_type(&self) -> &str

Retrieves the internal type of the entry. This can be one of the following:

• String,
• i32,
• u32,
• i64,
• u64,
• f32,
• f64,
• bool,
• char,
• na.

Examples

let entry = DataEntry::Text("some text".to_owned());
assert_eq!(entry.internal_type(), "String");

let entry = DataEntry::Character('a');
assert_eq!(entry.internal_type(), "char");

let entry = DataEntry::Integer(-234);
assert_eq!(entry.internal_type(), "i32");

Note that the internal type does not always correspond with the constructing type:

let entry = DataEntry::from(2u8);
assert_eq!(entry.internal_type(), "u32");

pub fn data_type(&self) -> DataType

Retrieves the type of the entry as a DataType.

Example

let entry = DataEntry::from(true);
assert_eq!(entry.data_type(), DataType::Boolean);

let entry = DataEntry::from(-2i8);
assert_eq!(entry.data_type(), DataType::Integer);

pub fn convert_to(&self, data_type: &DataType) -> DataEntry

Convert this entry into another data type. Note this does not modify the initial entry itself but returns a new entry with the desired type.

Note that some data types cannot be converted into one another as the conversion makes no sense. This results in DataType::NA entries. The conversion from numerical types into boolean values is performed by checking equality with 0.

Conversions that result in DataType::NA

• DataType::Text into another type that cannot be parsed into another type using String::from(). For example the conversion shown in the third example of this docstring.
• DataType::Character into DataType::Boolean.
• Anything except DataType::Text into DataType::Character. This can be somewhat circumvented by converting to DataType::Text and then into DataType::Character.
• Any signed numerical type into an unsigned one.
• DataType::Long into DataType::Integer.
• DataType::ULong into DataType::UInteger.

Examples

A working conversion:

let entry = DataEntry::from(true);
let new_entry = entry.convert_to(&DataType::Integer);
assert_eq!(new_entry, DataEntry::Integer(1));

A working yet lossy conversion:

// build double precision floating point DataEntry
let entry = DataEntry::from(123.456f64);
assert_eq!(entry.data_type(), DataType::Double);

// convert to single precision floating point
let new_entry = entry.convert_to(&DataType::Float);
assert_eq!(new_entry.data_type(), DataType::Float);
assert_eq!(new_entry, DataEntry::Float(123.456f32));

A conversion that makes no sense:

let entry = DataEntry::from("word");
let new_entry = entry.convert_to(&DataType::Character);
assert_eq!(new_entry, DataEntry::NA);

Trait Implementations

impl Debug for DataEntry

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

Formats the value using the given formatter.

impl Clone for DataEntry

fn clone(&self) -> DataEntry

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for DataEntry

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

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

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

This method tests for !=.

impl PartialOrd for DataEntry

fn partial_cmp(&self, other: &DataEntry) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &DataEntry) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &DataEntry) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &DataEntry) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &DataEntry) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Add for DataEntry

type Output = DataEntry

The resulting type after applying the + operator.

fn add(self, other: DataEntry) -> Self::Output

Performs the + operation.

impl Sub for DataEntry

type Output = DataEntry

The resulting type after applying the - operator.

fn sub(self, other: DataEntry) -> Self::Output

Performs the - operation.

impl Mul for DataEntry

type Output = DataEntry

The resulting type after applying the * operator.

fn mul(self, rhs: DataEntry) -> Self::Output

Performs the * operation.

impl Div for DataEntry

type Output = DataEntry

The resulting type after applying the / operator.

fn div(self, rhs: DataEntry) -> Self::Output

Performs the / operation.

impl From<i8> for DataEntry

fn from(integer: i8) -> Self

Performs the conversion.

impl From<u8> for DataEntry

fn from(integer: u8) -> Self

Performs the conversion.

impl From<i16> for DataEntry

fn from(integer: i16) -> Self

Performs the conversion.

impl From<u16> for DataEntry

fn from(integer: u16) -> Self

Performs the conversion.

impl From<i32> for DataEntry

fn from(integer: i32) -> Self

Performs the conversion.

impl From<u32> for DataEntry

fn from(integer: u32) -> Self

Performs the conversion.

impl From<i64> for DataEntry

fn from(integer: i64) -> Self

Performs the conversion.

impl From<u64> for DataEntry

fn from(integer: u64) -> Self

Performs the conversion.

impl From<f32> for DataEntry

fn from(float: f32) -> Self

Performs the conversion.

impl From<f64> for DataEntry

fn from(float: f64) -> Self

Performs the conversion.

impl From<bool> for DataEntry

fn from(boolean: bool) -> Self

Performs the conversion.

impl From<char> for DataEntry

fn from(character: char) -> Self

Performs the conversion.

impl From<String> for DataEntry

fn from(text: String) -> Self

Performs the conversion.

impl<'a> From<&'a String> for DataEntry

fn from(text: &'a String) -> Self

Performs the conversion.

impl<'a> From<&'a str> for DataEntry

fn from(text: &'a str) -> Self

Performs the conversion.