Enum ConstValue

pub enum ConstValue {
    Null,
    Bool(bool),
    Int(i64),
    Str(&'static str),
    Float(F64),
    BitVector(usize, u64),
    Expr(&'static Expr),
}

Represents a constant value that abstracts various literal types and expressions. This type encapsulates null, boolean, integer, string, floating-point, and expression values, each with respective formatting behavior for debugging and display purposes.

Variants

Null

Bool(bool)

Int(i64)

Str(&'static str)

Float(F64)

BitVector(usize, u64)

Expr(&'static Expr)

Implementations

impl ConstValue

pub fn parse(pair: Pair<'_, Rule>) -> Result<Self, Error>

Parses a Pair of '_, Rule> into a ConstValue, returning a result with either the parsed constant or an error.

impl ConstValue

pub fn ty(&self) -> Type

Returns the type corresponding to a constant value instance. This function maps each variant of the constant value to its respective type: integer, boolean, string, float, or null, with the expression variant treated as null.

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

Returns an optional boolean extracted from the constant. This function checks if the constant holds a boolean value, and if so, returns it wrapped in Some; otherwise, it returns None.

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

Returns the contained integer value if the input represents one. This function checks if the instance holds an integer and, if so, returns it inside an Option; otherwise, it yields None.

pub fn as_bv(&self) -> Option<u64>

Returns the contained integer value if the input represents one. This function checks if the instance holds an integer and, if so, returns it inside an Option; otherwise, it yields None.

pub fn as_usize(&self) -> Option<usize>

Converts the integer variant of a constant value into a usize if applicable.

Returns an Option containing the usize representation when the constant is an integer; otherwise, it produces None.

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

Returns an Option wrapping a static string reference if the constant holds a string value, or None otherwise. This method inspects the constant value and, when it represents a string, provides access to the underlying static string slice, enabling string-specific processing while gracefully handling non-string cases.

pub fn as_float(&self) -> Option<F64>

Returns the floating-point value contained in the constant, if available.

Checks whether the constant is of the float variant, and if so, returns its underlying value wrapped in an Option; otherwise, it produces None.

pub fn as_expr(&self) -> Option<&'static Expr>

Returns an optional static reference to an expression if the constant value represents an expression variant. This function checks whether the constant holds an expression and, if so, returns it wrapped in an option; otherwise, it returns None.

pub fn as_f64(&self) -> Option<f64>

Extracts a floating-point value from a constant if it represents a float. This function checks the internal variant and, when it holds a float, retrieves the underlying f64 value wrapped in an Option; otherwise, it returns None.

pub fn is_null(&self) -> bool

Checks whether a constant value is null.

Determines if the constant value represents a null literal and returns true if so, otherwise false.

pub fn value(&self, len: usize) -> Value

Converts a constant configuration into a collection value by replicating its underlying data over a specified length.

Matches on the constant variant to determine the appropriate data type and constructs a value by repeatedly inserting the constant element for each index in the specified range. For boolean, integer, string, and float constants, a collection of repeated elements is created, while attempting to convert a null or expression constant results in a panic.

Trait Implementations

impl Clone for ConstValue

fn clone(&self) -> ConstValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConstValue

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

Formats the value using the given formatter.

impl Display for ConstValue

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

Formats the value using the given formatter.

impl From<&'static Expr> for ConstValue

fn from(original: &'static Expr) -> ConstValue

Converts to this type from the input type.

impl From<&'static str> for ConstValue

fn from(original: &'static str) -> ConstValue

Converts to this type from the input type.

impl From<()> for ConstValue

fn from(original: ()) -> ConstValue

Converts to this type from the input type.

impl From<(usize, u64)> for ConstValue

fn from(original: (usize, u64)) -> ConstValue

Converts to this type from the input type.

impl From<F64> for ConstValue

fn from(original: F64) -> ConstValue

Converts to this type from the input type.

impl From<bool> for ConstValue

fn from(original: bool) -> ConstValue

Converts to this type from the input type.

impl From<i64> for ConstValue

fn from(original: i64) -> ConstValue

Converts to this type from the input type.

impl From<u32> for ConstValue

fn from(value: u32) -> Self

Converts an unsigned 32-bit integer into a constant integer value.

This function takes a u32 as input and returns the corresponding constant integer value by converting the input to a 64-bit integer internally.

impl From<usize> for ConstValue

fn from(value: usize) -> Self

Converts a usize value into a constant integer by casting it into a 64-bit integer.

Transforms a usize into its integer representation wrapped as a constant, enabling its use in contexts where a constant of integer type is expected.

impl Hash for ConstValue

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ConstValue

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

impl Eq for ConstValue

impl StructuralPartialEq for ConstValue