anyscript_compiler/types/float.rs
1use std::ffi::CString;
2use crate::alias::*;
3use crate::types::prelude::*;
4use std::hash::Hash;
5use std::fmt::{Display, Formatter, Result as FmtResult};
6use std::any::TypeId;
7use std::str::FromStr;
8
9#[derive(Clone)]
10pub struct Float<T1> {
11 pub floating: FloatAlias,
12 pub size: FloatAlias,
13 pub original: T1,
14 pub type_id: String,
15}
16
17impl<T1: 'static + Default + Display + PartialEq + Hash + Clone + Send + Sync> Default for Float<T1> {
18 fn default() -> Self {
19 Self::new()
20 }
21}
22
23impl<T1: 'static + Default + Display + PartialEq + Hash + Clone + Send + Sync> Float<T1> {
24 ///
25 /// # Create a new instance of the class
26 ///
27 /// ```rust
28 /// pub fn new() -> Self {
29 /// let n = T1::default();
30 /// Float {
31 /// floating: 0.0,
32 /// size: 0.0,
33 /// original: n,
34 /// type_id: String::new(),
35 /// }
36 /// }
37 /// ```
38 /// ---
39 pub fn new() -> Self {
40 let n = T1::default();
41 Float {
42 floating: 0.0,
43 size: 0.0,
44 original: n,
45 type_id: String::new(),
46 }
47 }
48
49 ///
50 /// # Reset the class
51 ///
52 /// ```rust
53 /// pub fn reset(&mut self) {
54 /// self.floating = 0.0;
55 /// self.size = 0.0;
56 /// self.type_id = String::new();
57 /// self.original = T1::default();
58 /// }
59 /// ```
60 /// ---
61 pub fn reset(&mut self) {
62 self.floating = 0.0;
63 self.size = 0.0;
64 self.original = T1::default();
65 self.type_id = String::new();
66 }
67
68 ///
69 /// # Check Valid
70 ///
71 /// ```rust
72 /// pub fn validate(&self) -> (bool, String) {
73 /// if TypeId::of::<T1>() == TypeId::of::<FloatAlias>() {
74 /// return (true, "float".to_string());
75 /// } else if TypeId::of::<T1>() == TypeId::of::<IntAlias>() {
76 /// return (true, "int".to_string());
77 /// } else if TypeId::of::<T1>() == TypeId::of::<UIntAlias>() {
78 /// return (true, "uint".to_string());
79 /// } else if TypeId::of::<T1>() == TypeId::of::<&str>() || TypeId::of::<T1>() == TypeId::of::<String>() {
80 /// let value = self.original.to_string();
81 /// if value.parse::<FloatAlias>().is_ok() {
82 /// return (true, "float".to_string());
83 /// } else if value.parse::<IntAlias>().is_ok() {
84 /// return (true, "int".to_string());
85 /// } else if value.parse::<UIntAlias>().is_ok() {
86 /// return (true, "uint".to_string());
87 /// } else {
88 /// return (false, "invalid string".to_string());
89 /// }
90 /// } else if TypeId::of::<T1>() == TypeId::of::<CString>() {
91 /// let c_str = self.original.to_string();
92 /// if c_str.parse::<FloatAlias>().is_ok() {
93 /// return (true, "float".to_string());
94 /// } else if c_str.parse::<IntAlias>().is_ok() {
95 /// return (true, "int".to_string());
96 /// } else if c_str.parse::<UIntAlias>().is_ok() {
97 /// return (true, "uint".to_string());
98 /// } else {
99 /// return (false, "invalid CString".to_string());
100 /// }
101 /// } else if TypeId::of::<T1>() == TypeId::of::<List<T1>>() {
102 /// let _raw: List<T1> = List::new(); // Explicit type annotation
103 /// let _type = _raw.get_type();
104 /// return (true, _type);
105 /// }
106 /// (false, "unsupported type".to_string())
107 /// }
108 /// ```
109 /// ---
110 pub fn validate(&self) -> (bool, String) {
111 if TypeId::of::<T1>() == TypeId::of::<FloatAlias>() {
112 return (true, "float".to_string());
113 } else if TypeId::of::<T1>() == TypeId::of::<IntAlias>() {
114 return (true, "int".to_string());
115 } else if TypeId::of::<T1>() == TypeId::of::<UIntAlias>() {
116 return (true, "uint".to_string());
117 } else if TypeId::of::<T1>() == TypeId::of::<&str>() || TypeId::of::<T1>() == TypeId::of::<String>() {
118 let value = self.original.to_string();
119 if value.parse::<FloatAlias>().is_ok() {
120 return (true, "float".to_string());
121 } else if value.parse::<IntAlias>().is_ok() {
122 return (true, "int".to_string());
123 } else if value.parse::<UIntAlias>().is_ok() {
124 return (true, "uint".to_string());
125 } else {
126 return (false, "invalid string".to_string());
127 }
128 } else if TypeId::of::<T1>() == TypeId::of::<CString>() {
129 let c_str = self.original.to_string();
130 if c_str.parse::<FloatAlias>().is_ok() {
131 return (true, "float".to_string());
132 } else if c_str.parse::<IntAlias>().is_ok() {
133 return (true, "int".to_string());
134 } else if c_str.parse::<UIntAlias>().is_ok() {
135 return (true, "uint".to_string());
136 } else {
137 return (false, "invalid CString".to_string());
138 }
139 } else if TypeId::of::<T1>() == TypeId::of::<List<T1>>() {
140 let _raw: List<T1> = List::new(); // Explicit type annotation
141 let _type = _raw.get_type();
142 return (true, _type);
143 }
144 (false, "unsupported type".to_string())
145 }
146
147 /// # Convert Floating to Int, with Optional set to 32 bit or 64 bit
148 ///
149 /// ```rust
150 /// pub fn to_int(&mut self, bit32: Option<bool>) {
151 /// let if_32 = bit32.unwrap_or(true); // Default is true
152 /// if if_32 {
153 /// self.floating = self.floating as f32 as FloatAlias;
154 /// } else {
155 /// self.floating = self.floating as f64 as FloatAlias;
156 /// }
157 /// }
158 /// ```
159 pub fn to_int(&mut self, bit32: Option<bool>) {
160 let if_32 = bit32.unwrap_or(true); // Default is true
161 if if_32 {
162 self.floating = self.floating as f32 as FloatAlias;
163 } else {
164 self.floating = self.floating as FloatAlias;
165 }
166 }
167
168 /// # Convert to String
169 ///
170 /// ```rust
171 /// pub fn to_str(&self) -> String {
172 /// self.floating.to_string()
173 /// }
174 /// ```
175 pub fn to_str(&self) -> String {
176 self.floating.to_string()
177 }
178
179 /// # Convert to an CString
180 ///
181 /// ```rust
182 /// pub fn to_cstring(&self) -> CString {
183 /// let _nstring = self.to_str();
184 /// let _cstr = CString::new(_nstring).unwrap();
185 /// _cstr
186 /// }
187 /// ```
188 pub fn to_cstring(&self) -> CString {
189 let _nstring = self.to_str();
190
191 CString::new(_nstring).unwrap()
192 }
193
194 /// # Convert from String
195 ///
196 /// ```rust
197 /// pub fn from_string(s: &str) -> Result<Self, <FloatAlias as FromStr>::Err> {
198 /// let floating = s.parse::<FloatAlias>()?;
199 /// Ok(Float {
200 /// floating,
201 /// size: 0.0,
202 /// original: T1::default(),
203 /// type_id: String::new(),
204 /// })
205 /// }
206 /// ```
207 pub fn from_string(s: &str) -> Result<Self, <FloatAlias as FromStr>::Err> {
208 let floating = s.parse::<FloatAlias>()?;
209 Ok(Float {
210 floating,
211 size: 0.0,
212 original: T1::default(),
213 type_id: String::new(),
214 })
215 }
216}
217
218impl<T1: 'static + Default + Display + PartialEq + Hash + Clone + Send + Sync> Display for Float<T1> {
219 fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
220 write!(f, "{}", self.floating)
221 }
222}