Struct LiteralValue 

pub struct LiteralValue {
    pub value: Value,
    pub lemma_type: LemmaType,
}

A literal value with its type

Every literal value knows its type - no distinction between standard and custom types.

Fields

value: Value

lemma_type: LemmaType

Implementations

impl LiteralValue

pub fn number<T: Into<Decimal>>(value: T) -> Self

Create a Number literal value from any type that can convert to Decimal Uses STANDARD_NUMBER as the type

pub fn number_with_type<T: Into<Decimal>>( value: T, lemma_type: LemmaType, ) -> Self

Create a Number literal value with a custom type

pub fn scale<T: Into<Decimal>>(value: T, unit: Option<String>) -> Self

Create a Scale literal value Uses the provided type (must be a Scale type)

pub fn scale_with_type<T: Into<Decimal>>( value: T, unit: Option<String>, lemma_type: LemmaType, ) -> Self

Create a Scale literal value with a custom type

pub fn text(value: String) -> Self

Create a Text literal value Uses STANDARD_TEXT as the type

pub fn text_with_type(value: String, lemma_type: LemmaType) -> Self

Create a Text literal value with a custom type

pub fn boolean(value: BooleanValue) -> Self

Create a Boolean literal value Uses STANDARD_BOOLEAN as the type

pub fn boolean_with_type(value: BooleanValue, lemma_type: LemmaType) -> Self

Create a Boolean literal value with a custom type

pub fn date(value: DateTimeValue) -> Self

Create a Date literal value Uses STANDARD_DATE as the type

pub fn date_with_type(value: DateTimeValue, lemma_type: LemmaType) -> Self

Create a Date literal value with a custom type

pub fn time(value: TimeValue) -> Self

Create a Time literal value Uses STANDARD_TIME as the type

pub fn time_with_type(value: TimeValue, lemma_type: LemmaType) -> Self

Create a Time literal value with a custom type

pub fn duration(value: Decimal, unit: DurationUnit) -> Self

Create a Duration literal value Uses STANDARD_DURATION as the type

pub fn duration_with_type( value: Decimal, unit: DurationUnit, lemma_type: LemmaType, ) -> Self

Create a Duration literal value with a custom type

pub fn ratio<T: Into<Decimal>>(value: T, unit: Option<String>) -> Self

Create a Ratio literal value Uses STANDARD_RATIO as the type

pub fn ratio_with_type<T: Into<Decimal>>( value: T, unit: Option<String>, lemma_type: LemmaType, ) -> Self

Create a Ratio literal value with a custom type

pub fn get_type(&self) -> &LemmaType

Get the type of this literal value

pub fn display_value(&self) -> String

Get the display value as a string (uses the Display implementation)

pub fn byte_size(&self) -> usize

Get the byte size of this literal value for resource limiting

Trait Implementations

impl Clone for LiteralValue

fn clone(&self) -> LiteralValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LiteralValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LiteralValue

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LiteralValue

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

Formats the value using the given formatter.

impl PartialEq for LiteralValue

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for LiteralValue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LiteralValue