Enum bones_framework::prelude::piccolo::Constant

pub enum Constant<S> {
    Nil,
    Boolean(bool),
    Integer(i64),
    Number(f64),
    String(S),
}

Variants

Nil

Boolean(bool)

Integer(i64)

Number(f64)

String(S)

Implementations

impl<S> Constant<S>

pub fn to_bool(&self) -> bool

pub fn not(&self) -> Constant<S>

pub fn as_string_ref(&self) -> Constant<&S>

pub fn map_string<S2>(self, f: impl FnOnce(S) -> S2) -> Constant<S2>

impl<S> Constant<S>

where S: AsRef<[u8]>,

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

Interprets Numbers, Integers, and Strings as a Number, if possible.

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

Interprets Numbers, Integers, and Strings as an Integer, if possible.

pub fn add(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn subtract(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn multiply(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn float_divide(&self, rhs: &Constant<S>) -> Option<Constant<S>>

This operation always returns a Number, even when called with Integer arguments.

pub fn floor_divide(&self, rhs: &Constant<S>) -> Option<Constant<S>>

This operation returns an Integer only if both arguments are Integers. Rounding is towards negative infinity.

pub fn modulo(&self, rhs: &Constant<S>) -> Option<Constant<S>>

Computes the Lua modulus (%) operator. This is unlike Rust’s % operator which computes the remainder.

pub fn exponentiate(&self, rhs: &Constant<S>) -> Option<Constant<S>>

This operation always returns a Number, even when called with Integer arguments.

pub fn negate(&self) -> Option<Constant<S>>

pub fn bitwise_not(&self) -> Option<Constant<S>>

pub fn bitwise_and(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn bitwise_or(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn bitwise_xor(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn shift_left(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn shift_right(&self, rhs: &Constant<S>) -> Option<Constant<S>>

pub fn is_equal(&self, other: &Constant<S>) -> bool

pub fn less_than(&self, rhs: &Constant<S>) -> Option<bool>

pub fn less_equal(&self, rhs: &Constant<S>) -> Option<bool>

Trait Implementations

impl<S> Clone for Constant<S>

where S: Clone,

fn clone(&self) -> Constant<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Collect for Constant<S>

where S: Collect,

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, cc: &Collection)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl<S> Debug for Constant<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<S> From<Constant<S>> for IdenticalConstant<S>

fn from(value: Constant<S>) -> IdenticalConstant<S>

Converts to this type from the input type.

impl<'gc, S> From<Constant<S>> for Value<'gc>

where String<'gc>: From<S>,

fn from(constant: Constant<S>) -> Value<'gc>

Converts to this type from the input type.

impl<S> PartialEq for Constant<S>

where S: AsRef<[u8]>,

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

where S: Copy,