Enum sfv::BareItem

pub enum BareItem {
    Decimal(Decimal),
    Integer(i64),
    String(String),
    ByteSeq(Vec<u8>),
    Boolean(bool),
    Token(String),
}

BareItem type is used to construct Items or Parameters values.

Variants

Decimal(Decimal)

Decimal number

Integer(i64)

Integer number

String(String)

ByteSeq(Vec<u8>)

Boolean(bool)

Token(String)

Implementations

impl BareItem

pub fn as_decimal(&self) -> Option<Decimal>

If BareItem is a decimal, returns Decimal, otherwise returns None.

let decimal_number = Decimal::from_f64(415.566).unwrap();
let bare_item: BareItem = decimal_number.into();
assert_eq!(bare_item.as_decimal().unwrap(), decimal_number);

pub fn as_int(&self) -> Option<i64>

If BareItem is an integer, returns i64, otherwise returns None.

let bare_item: BareItem = 100.into();
assert_eq!(bare_item.as_int().unwrap(), 100);

pub fn as_str(&self) -> Option<&str>

If BareItem is String, returns &str, otherwise returns None.

let bare_item = BareItem::String("foo".into());
assert_eq!(bare_item.as_str().unwrap(), "foo");

pub fn as_byte_seq(&self) -> Option<&Vec<u8>>

If BareItem is a ByteSeq, returns &Vec<u8>, otherwise returns None.

let bare_item = BareItem::ByteSeq("foo".to_owned().into_bytes());
assert_eq!(bare_item.as_byte_seq().unwrap().as_slice(), "foo".as_bytes());

pub fn as_bool(&self) -> Option<bool>

If BareItem is a Boolean, returns bool, otherwise returns None.

let bare_item = BareItem::Boolean(true);
assert_eq!(bare_item.as_bool().unwrap(), true);

pub fn as_token(&self) -> Option<&str>

If BareItem is a Token, returns &str, otherwise returns None.

use sfv::BareItem;

let bare_item = BareItem::Token("*bar".into());
assert_eq!(bare_item.as_token().unwrap(), "*bar");

Trait Implementations

impl Clone for BareItem

fn clone(&self) -> BareItem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BareItem

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

Formats the value using the given formatter.

impl From<Decimal> for BareItem

fn from(item: Decimal) -> Self

Converts Decimal into BareItem::Decimal.

let decimal_number = Decimal::from_f64(48.01).unwrap();
let bare_item: BareItem = decimal_number.into();
assert_eq!(bare_item.as_decimal().unwrap(), decimal_number);

impl From<i64> for BareItem

fn from(item: i64) -> Self

Converts i64 into BareItem::Integer.

let bare_item: BareItem = 456.into();
assert_eq!(bare_item.as_int().unwrap(), 456);

impl PartialEq for BareItem

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for BareItem