Struct anyscript_compiler::types::int::Int

pub struct Int<T1> {
    pub integral: IntAlias,
    pub size: IntAlias,
    pub original: T1,
    pub type_id: String,
}

Fields

integral: IntAlias

size: IntAlias

original: T1

type_id: String

Implementations

impl<T1: 'static + Default + Display + Eq + Hash + Clone + Send + Sync> Int<T1>

pub fn new() -> Self

Create a new instance of the class

pub fn new() -> Self {
    let n = T1::default();
    Int {
        integral: 0,
        size: 0,
        original: n,
        type_id: String::new(),
    }
}

---

pub fn reset(&mut self)

Reset the class

pub fn reset(&mut self) {
    self.integral = 0;
    self.size = 0;
    self.type_id = String::new();
    self.original = T1::default();
}

---

pub fn validate(&self) -> (bool, String)

Check Valid

pub fn validate(&self) -> (bool, String) {
    if TypeId::of::<T1>() == TypeId::of::<IntAlias>() {
        return (true, "int".to_string());
    } else if TypeId::of::<T1>() == TypeId::of::<FloatAlias>() {
        return (true, "float".to_string());
    } else if TypeId::of::<T1>() == TypeId::of::<UIntAlias>() {
        return (true, "uint".to_string());
    } else if TypeId::of::<T1>() == TypeId::of::<&str>() || TypeId::of::<T1>() == TypeId::of::<String>() {
        let value = self.original.to_string();
        if value.parse::<IntAlias>().is_ok() {
            return (true, "int".to_string());
        } else if value.parse::<FloatAlias>().is_ok() {
            return (true, "float".to_string());
        } else if value.parse::<UIntAlias>().is_ok() {
            return (true, "uint".to_string());
        } else {
            return (false, "invalid string".to_string());
        }
    } else if TypeId::of::<T1>() == TypeId::of::<CString>() {
        let c_str = self.original.to_string();
        if c_str.parse::<IntAlias>().is_ok() {
            return (true, "int".to_string());
        } else if c_str.parse::<FloatAlias>().is_ok() {
            return (true, "float".to_string());
        } else if c_str.parse::<UIntAlias>().is_ok() {
            return (true, "uint".to_string());
        } else {
            return (false, "invalid CString".to_string());
        }
    } else if TypeId::of::<T1>() == TypeId::of::<List<T1>>() {
        let _raw: List<T1> = List::new(); // Explicit type annotation
        let _type = _raw.get_type();
        return (true, _type);
    }
    (false, "unsupported type".to_string())
}

---

pub fn to_float(&mut self, bit32: Option<bool>)

Convert Integral to Float, with Optional set to 32 bit or 64 bit

pub fn to_float(&mut self, bit32: Option<bool>) {
    let if_32 = bit32.unwrap_or(true); // Default is true
    if if_32 {
        self.integral = self.integral as f32 as IntAlias;
    } else {
        self.integral = self.integral as f64 as IntAlias;
    }
}

pub fn to_str(&self) -> String

Convert to String

pub fn to_str(&self) -> String {
    self.integral.to_string()
}

pub fn to_cstring(&self) -> CString

Convert to an CString

pub fn to_cstring(&self) -> CString {
    let _nstring = self.to_str();
    let _cstr = CString::new(_nstring).unwrap();
    _cstr
}

pub fn from_string(s: &str) -> Result<Self, <IntAlias as FromStr>::Err>

Convert from String

pub fn from_string(s: &str) -> Result<Self, <IntAlias as FromStr>::Err> {
    let integral = s.parse::<IntAlias>()?;
    Ok(Int {
        integral,
        size: 0,
        original: T1::default(),
        type_id: String::new(),
    })
}

Trait Implementations

impl<T1: Clone> Clone for Int<T1>

fn clone(&self) -> Int<T1>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T1: 'static + Default + Display + Eq + Hash + Clone + Send + Sync> Default for Int<T1>

fn default() -> Self

Returns the “default value” for a type.

impl<T1: 'static + Default + Display + Eq + Hash + Clone + Send + Sync> Display for Int<T1>

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

Formats the value using the given formatter.