Renamed NumberValue in EncodedNumberValue and fixed requested changes

Author: Laschoking

nemo-physical/src/function/definitions/casting.rs

@@ -36,11 +36,18 @@ impl UnaryFunction for CastingIntoInteger64 {
                 let lex_val = parameter.lexical_value();
 
                 // Handle decimal, binary (0b), octal (0o) and hexadecimal (0x) encoded strings
-                let result = match &lex_val[0..2] {
-                    "0b" => <i64>::from_str_radix(&lex_val[2..], 2).ok()?,
-                    "0o" => <i64>::from_str_radix(&lex_val[2..], 8).ok()?,
-                    "0x" => <i64>::from_str_radix(&lex_val[2..], 16).ok()?,
-                    _ => lex_val.parse::<i64>().ok()?,
+                // Expect 2 chars for encoding prefix and at least one char as suffix
+                let result = {
+                    if lex_val.chars().count() >= 3 {
+                        match &lex_val[0..2] {
+                            "0b" => <i64>::from_str_radix(&lex_val[2..], 2).ok()?,
+                            "0o" => <i64>::from_str_radix(&lex_val[2..], 8).ok()?,
+                            "0x" => <i64>::from_str_radix(&lex_val[2..], 16).ok()?,
+                            _ => lex_val.parse::<i64>().ok()?,
+                        }
+                    } else {
+                        lex_val.parse::<i64>().ok()?
+                    }
                 };
 
                 Some(AnyDataValue::new_integer_from_i64(result))

nemo/src/parser/ast/expression/basic/enc_number.rs

@@ -13,7 +13,7 @@ use crate::parser::{
     span::Span,
     ParserInput, ParserResult,
 };
-use num::{BigInt, Num};
+use num::{BigInt,Num};
 
 /// Define a different type for each prefix token
 #[derive(Assoc, Debug, Clone, Copy, PartialEq, Eq)]
@@ -32,7 +32,6 @@ enum Encoding {
 }
 
 impl Encoding {
-
     /// Returns the base of each encoding type
     pub fn radix(&self) -> u32 {
         match self {
@@ -48,6 +47,7 @@ impl Encoding {
 pub struct EncodedNumber<'a> {
     /// [Span] associated with this node
     span: Span<'a>,
+
     /// The prefix of the encoded number
     prefix: Encoding,
     /// The suffix of the encoded number
@@ -64,7 +64,6 @@ pub enum EncodedNumberValue {
 }
 
 impl<'a> EncodedNumber<'a> {
-    
     /// Removes the binary prefix (0b) and returns the binary suffix
     fn parse_binary(input: ParserInput<'a>) -> ParserResult<'a, (Encoding, Token<'a>)> {
         preceded(Token::binary_prefix, Token::bin_number)(input)
@@ -96,7 +95,7 @@ impl<'a> EncodedNumber<'a> {
         // Otherwise, return string representation of the decoded number
         if let Ok(integer) = <i64>::from_str_radix(suffix, nr_encoding) {
             return EncodedNumberValue::Integer(integer);
-        } else if let Ok(bigint) = <BigInt as Num>::from_str_radix(suffix, nr_encoding) {
+        } else if let Ok(bigint) = BigInt::from_str_radix(suffix, nr_encoding) {
             return EncodedNumberValue::Large(bigint.to_string());
         }
         EncodedNumberValue::Large(string)

nemo/src/parser/ast/expression/basic/number.rs

@@ -136,7 +136,7 @@ impl<'a> Number<'a> {
         if let Ok(float) = str::parse::<f32>(&string) {
             return NumberValue::Float(float);
         }
-        
+
         NumberValue::Large(string)
     }
 

nemo/src/parser/ast/token.rs

@@ -28,9 +28,9 @@ use crate::{
     syntax::{
         self, comment,
         datavalues::{self, boolean, iri, map, string, tuple, RDF_DATATYPE_INDICATOR},
-        directive,
+        directive, encoding_prefixes, 
         expression::{aggregate, atom, format_string, operation, variable},
-        operator, rule,
+        operator, rule, 
     },
 };
 
@@ -185,21 +185,21 @@ pub enum TokenKind {
     /// Digits
     #[assoc(name = "digits")]
     Digits,
-    /// Binary prefix
-    #[assoc(name = "0b")]
+    /// Token preceding a binary encoded number as defined in [BIN](encoding_prefixes::BIN)
+    #[assoc(name = encoding_prefixes::BIN)]
     BinaryPrefix,
+    /// Token preceding an octal encoded number as defined in [OCT](encoding_prefixes::OCT)
+    #[assoc(name = encoding_prefixes::OCT)]
+    OctalPrefix,
+    /// Token preceding a hexadecimal encoded number as defined in [HEX](encoding_prefixes::HEX)
+    #[assoc(name = encoding_prefixes::HEX)]
+    HexPrefix,
     /// Binary suffix
     #[assoc(name = "bin_suffix")]
     BinarySuffix,
-    /// Octal prefix
-    #[assoc(name = "0o")]
-    OctalPrefix,
     /// Octal suffix
     #[assoc(name = "oct_suffix")]
     OctalSuffix,
-    /// Hexadecimal prefix
-    #[assoc(name = "0x")]
-    HexPrefix,
     /// Hexadecimal suffix
     #[assoc(name = "hex_suffix")]
     HexSuffix,

nemo/src/rule_model/translation/basic/enc_number.rs

@@ -20,10 +20,10 @@ impl TranslationComponent for EncodedNumberLiteral {
         enc_number: &'b Self::Ast<'a>,
     ) -> Result<Self, TranslationError> {
         Ok(EncodedNumberLiteral(match enc_number.value() {
-            ast::expression::basic::enc_number::NumberValue::Integer(integer) => {
+            ast::expression::basic::enc_number::EncodedNumberValue::Integer(integer) => {
                 AnyDataValue::new_integer_from_i64(integer)
             }
-            ast::expression::basic::enc_number::NumberValue::Large(large) => {
+            ast::expression::basic::enc_number::EncodedNumberValue::Large(large) => {
                 AnyDataValue::new_other(large, String::from("xsd:integer"))
             }
         }))

nemo/src/syntax.rs

@@ -366,6 +366,17 @@ pub mod datavalues {
     pub const DOT: &str = ".";
 }
 
+pub mod encoding_prefixes {
+    //! This module defines the prefixes for encoded numbers
+
+    /// Reprsents the prefix for binary-encoded unsigned integers
+    pub const BIN: &str = "0b";
+    /// Reprsents the prefix for octal-encoded unsigned integers
+    pub const OCT: &str = "0o";
+    /// Reprsents the prefix for hex-encoded unsigned integers
+    pub const HEX: &str = "0x";
+}
+
 pub mod import_export {
     //! This module defines the import/export configuration options.