feat(rad): new RadonInteger operators

Author: guidiaz

Cargo.lock

@@ -5,8 +5,8 @@ use serde_cbor::value::{Value, from_value};
 use crate::{
     error::RadError,
     types::{
-        RadonType, boolean::RadonBoolean, float::RadonFloat, integer::RadonInteger,
-        string::RadonString,
+        RadonType, boolean::RadonBoolean, bytes::RadonBytes, float::RadonFloat,
+        integer::RadonInteger, string::RadonString,
     },
 };
 
@@ -20,6 +20,20 @@ pub fn absolute(input: &RadonInteger) -> Result<RadonInteger, RadError> {
     }
 }
 
+pub fn to_bytes(input: RadonInteger) -> Result<RadonBytes, RadError> {
+    let mut bytes_array = [0u8; 16];
+    bytes_array.copy_from_slice(&input.value().to_be_bytes());
+    let mut leading_zeros = 0;
+    for i in 0..bytes_array.len() {
+        if bytes_array[i] != 0u8 {
+            break;
+        } else {
+            leading_zeros += 1;
+        }
+    }
+    Ok(RadonBytes::from(bytes_array[leading_zeros..].to_vec()))
+}
+
 pub fn to_float(input: RadonInteger) -> Result<RadonFloat, RadError> {
     RadonFloat::try_from(Value::Integer(input.value()))
 }

rad/src/operators/integer.rs

@@ -58,16 +58,15 @@ pub enum RadonOpCodes {
     ///////////////////////////////////////////////////////////////////////
     // Integer operator codes (start at 0x40)
     IntegerAbsolute = 0x40,
-    IntegerAsFloat = 0x41,
-    IntegerAsString = 0x42,
     IntegerGreaterThan = 0x43,
     IntegerLessThan = 0x44,
-    //    IntegerMatch = 0x45,
     IntegerModulo = 0x46,
     IntegerMultiply = 0x47,
     IntegerNegate = 0x48,
     IntegerPower = 0x49,
-    //    IntegerReciprocal = 0x4A,
+    IntegerToBytes = 0x4A,
+    IntegerToFloat = 0x41,
+    IntegerToString = 0x42,
     //    IntegerSum = 0x4B,
     ///////////////////////////////////////////////////////////////////////
     // Float operator codes (start at 0x50)

rad/src/operators/mod.rs

@@ -105,12 +105,6 @@ impl Operable for RadonInteger {
             (RadonOpCodes::IntegerAbsolute, None) => {
                 integer_operators::absolute(self).map(RadonTypes::from)
             }
-            (RadonOpCodes::IntegerAsFloat, None) => {
-                integer_operators::to_float(self.clone()).map(RadonTypes::from)
-            }
-            (RadonOpCodes::IntegerAsString, None) => {
-                integer_operators::to_string(self.clone()).map(RadonTypes::from)
-            }
             (RadonOpCodes::IntegerGreaterThan, Some(args)) => {
                 integer_operators::greater_than(self, args).map(Into::into)
             }
@@ -129,6 +123,15 @@ impl Operable for RadonInteger {
             (RadonOpCodes::IntegerPower, Some(args)) => {
                 integer_operators::power(self, args.as_slice()).map(Into::into)
             }
+            (RadonOpCodes::IntegerToBytes, None) => integer_operators::to_bytes(self.clone())
+                .map(RadonTypes::from)
+                .map_err(Into::into),
+            (RadonOpCodes::IntegerToFloat, None) => {
+                integer_operators::to_float(self.clone()).map(RadonTypes::from)
+            }
+            (RadonOpCodes::IntegerToString, None) => {
+                integer_operators::to_string(self.clone()).map(RadonTypes::from)
+            }
             // Unsupported / unimplemented
             (op_code, args) => Err(RadError::UnsupportedOperator {
                 input_type: RADON_INTEGER_TYPE_NAME.to_string(),