Struct jomini::Scalar

pub struct Scalar<'a> { /* private fields */ }

A byte slice that represents a single value.

A scalars does not carry with it an encoding, so an appropriate encoder must be used if text is wished to be extracted from a scalar

use jomini::Scalar;

let v1 = Scalar::new(b"10");
assert_eq!(v1.to_u64(), Ok(10));
assert_eq!(v1.to_i64(), Ok(10));
assert_eq!(v1.to_f64(), Ok(10.0));
assert!(v1.to_bool().is_err());

Implementations

impl<'a> Scalar<'a>

pub fn new(data: &'a [u8]) -> Scalar<'a>

Create a new scalar backed by a byte slice

pub fn as_bytes(self) -> &'a [u8]

View the raw data

pub fn to_f64(self) -> Result<f64, ScalarError>

Try converting the scalar to f64

use jomini::Scalar;

let v1 = Scalar::new(b"1.000");
assert_eq!(v1.to_f64(), Ok(1.0));

let v2 = Scalar::new(b"-5.67821");
assert_eq!(v2.to_f64(), Ok(-5.67821));

pub fn to_bool(self) -> Result<bool, ScalarError>

Try converting the scalar to boolean, only “yes” and “no” can be mapped:

use jomini::Scalar;

let v1 = Scalar::new(b"yes");
assert_eq!(v1.to_bool(), Ok(true));

let v2 = Scalar::new(b"no");
assert_eq!(v2.to_bool(), Ok(false));

pub fn to_i64(self) -> Result<i64, ScalarError>

Try converting the scalar to i64

use jomini::Scalar;

let v1 = Scalar::new(b"-50");
assert_eq!(v1.to_i64(), Ok(-50));

let v2 = Scalar::new(b"120");
assert_eq!(v2.to_i64(), Ok(120));

pub fn to_u64(self) -> Result<u64, ScalarError>

Try converting the scalar to u64

use jomini::Scalar;

let v1 = Scalar::new(b"50");
assert_eq!(v1.to_i64(), Ok(50));

let v2 = Scalar::new(b"120");
assert_eq!(v2.to_i64(), Ok(120));

pub fn is_ascii(self) -> bool

Returns if the scalar contains only ascii values

use jomini::Scalar;

let v1 = Scalar::new(b"a");
assert!(v1.is_ascii());

let v2 = Scalar::new(&[255][..]);
assert!(!v2.is_ascii());

Trait Implementations

impl<'a> Clone for Scalar<'a>

fn clone(&self) -> Scalar<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Scalar<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Scalar<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Scalar<'a>

fn eq(&self, other: &Scalar<'a>) -> 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<'a> Copy for Scalar<'a>

impl<'a> Eq for Scalar<'a>

impl<'a> StructuralPartialEq for Scalar<'a>