feat: add const char* constructors to Decimal and Int128

Author: ronan-fesselier

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ### Added
 
-- NIL
+- Added `Decimal(const char*)` and  `Int128(const char*)` constructors for C-string initialization
 
 ### Changed
 

include/nfx/datatypes/Decimal.h

@@ -236,33 +236,41 @@ namespace nfx::datatypes
          * @brief Construct from 32-bit integer
          * @param value Integer value to convert
          */
-        explicit inline Decimal( std::int32_t value ) noexcept;
+        inline explicit Decimal( std::int32_t value ) noexcept;
 
         /**
          * @brief Construct from 64-bit integer
          * @param value Integer value to convert
          */
-        explicit inline Decimal( std::int64_t value ) noexcept;
+        inline explicit Decimal( std::int64_t value ) noexcept;
 
         /**
          * @brief Construct from 32-bit unsigned integer
          * @param value Unsigned integer value to convert
          */
-        explicit inline Decimal( std::uint32_t value ) noexcept;
+        inline explicit Decimal( std::uint32_t value ) noexcept;
 
         /**
          * @brief Construct from 64-bit unsigned integer
          * @param value Unsigned integer value to convert
          */
-        explicit inline Decimal( std::uint64_t value ) noexcept;
+        inline explicit Decimal( std::uint64_t value ) noexcept;
 
         /**
          * @brief Construct from string (exact parsing)
          * @param str String representation (e.g., "123.456")
          * @throws std::invalid_argument if string is not a valid decimal
          * @see fromString() for non-throwing parsing
          */
-        explicit inline Decimal( std::string_view str );
+        inline explicit Decimal( std::string_view str );
+
+        /**
+         * @brief Construct from C-string (exact parsing)
+         * @param scStr Null-terminated C-string representation (e.g., "123.456")
+         * @throws std::invalid_argument if string is not a valid decimal
+         * @see fromString() for non-throwing parsing
+         */
+        inline explicit Decimal( const char* scStr );
 
         /**
          * @brief Construct from 128-bit integer with overflow detection

include/nfx/datatypes/Int128.h

@@ -200,6 +200,13 @@ namespace nfx::datatypes
          */
         inline explicit Int128( std::string_view str );
 
+        /**
+         * @brief Construct from C-string (exact parsing)
+         * @param scStr Null-terminated C-string representation (e.g., "123", "-456789")
+         * @throws std::invalid_argument if string is not a valid integer
+         */
+        inline explicit Int128( const char* scStr );
+
         /**
          * @brief Construct from single-precision floating-point value
          * @param val Float value to convert

include/nfx/detail/datatypes/Decimal.inl

@@ -94,6 +94,11 @@ namespace nfx::datatypes
         }
     }
 
+    inline Decimal::Decimal( const char* scStr )
+        : Decimal{ std::string_view{ scStr } }
+    {
+    }
+
     //----------------------------------------------
     // Comparison with built-in floating point types
     //----------------------------------------------

include/nfx/detail/datatypes/Int128.inl

@@ -84,6 +84,11 @@ namespace nfx::datatypes
         }
     }
 
+    inline Int128::Int128( const char* scStr )
+        : Int128{ std::string_view{ scStr } }
+    {
+    }
+
     inline constexpr Int128::Int128( std::uint64_t low, std::uint64_t high ) noexcept
         : m_value{ static_cast<NFX_DATATYPES_NATIVE_INT128>( high ) << constants::BITS_PER_UINT64 | low }
     {
@@ -398,6 +403,11 @@ namespace nfx::datatypes
         }
     }
 
+    inline Int128::Int128( const char* scStr )
+        : Int128{ std::string_view{ scStr } }
+    {
+    }
+
     inline constexpr Int128::Int128( std::uint64_t low, std::uint64_t high ) noexcept
         : m_layout{ low, high }
     {

test/Tests_Decimal.cpp

@@ -2444,6 +2444,39 @@ namespace nfx::datatypes::test
         EXPECT_FALSE( d5 == 0 );
     }
 
+    TEST( DecimalStringParsing, CStringConstruction )
+    {
+        // Valid C-strings - tests const char* constructor
+        const char* str1 = "123.456";
+        datatypes::Decimal d1{ str1 };
+        EXPECT_EQ( d1.toString(), "123.456" );
+
+        const char* str2 = "-789.123";
+        datatypes::Decimal d2{ str2 };
+        EXPECT_TRUE( d2 < 0 );
+
+        const char* str3 = "0";
+        datatypes::Decimal d3{ str3 };
+        EXPECT_TRUE( d3 == 0 );
+
+        const char* str4 = "0.0001";
+        datatypes::Decimal d4{ str4 };
+        EXPECT_FALSE( d4 == 0 );
+
+        // Test with many Decimal places
+        const char* str5 = "123.1234567890123456789";
+        datatypes::Decimal d5{ str5 };
+        EXPECT_FALSE( d5 == 0 );
+
+        // Test invalid C-string throws exception
+        const char* invalid = "invalid";
+        EXPECT_THROW( datatypes::Decimal{ invalid }, std::invalid_argument );
+
+        // Test empty string throws exception
+        const char* empty = "";
+        EXPECT_THROW( datatypes::Decimal{ empty }, std::invalid_argument );
+    }
+
     TEST( DecimalStringParsing, FromStringMethod )
     {
         datatypes::Decimal result;

test/Tests_Int128.cpp

@@ -2162,6 +2162,51 @@ namespace nfx::datatypes::test
         EXPECT_FALSE( datatypes::Int128::fromString( "1e10", result ) );
     }
 
+    TEST( Int128StringParsing, CStringConstruction )
+    {
+        // Valid C-strings - tests const char* constructor
+        const char* str1 = "12345";
+        datatypes::Int128 i1{ str1 };
+        EXPECT_EQ( 12345ULL, i1.toLow() );
+        EXPECT_FALSE( i1 < 0 );
+
+        const char* str2 = "-9876543210";
+        datatypes::Int128 i2{ str2 };
+        EXPECT_TRUE( i2 < 0 );
+
+        const char* str3 = "0";
+        datatypes::Int128 i3{ str3 };
+        EXPECT_TRUE( i3 == 0 );
+
+        const char* str4 = "123456789012345678901234567890";
+        datatypes::Int128 i4{ str4 };
+        EXPECT_FALSE( i4 == 0 );
+        EXPECT_FALSE( i4 < 0 );
+
+        const char* str5 = "-123456789012345678901234567890";
+        datatypes::Int128 i5{ str5 };
+        EXPECT_TRUE( i5 < 0 );
+
+        const char* str6 = "+42";
+        datatypes::Int128 i6{ str6 };
+        EXPECT_EQ( 42ULL, i6.toLow() );
+        EXPECT_FALSE( i6 < 0 );
+
+        // Test invalid C-string throws exception
+        const char* invalid1 = "abc";
+        EXPECT_THROW( datatypes::Int128{ invalid1 }, std::invalid_argument );
+
+        const char* invalid2 = "123abc";
+        EXPECT_THROW( datatypes::Int128{ invalid2 }, std::invalid_argument );
+
+        const char* invalid3 = "12.34";
+        EXPECT_THROW( datatypes::Int128{ invalid3 }, std::invalid_argument );
+
+        // Test empty string throws exception
+        const char* empty = "";
+        EXPECT_THROW( datatypes::Int128{ empty }, std::invalid_argument );
+    }
+
     TEST( Int128StringParsing, ParseMethod )
     {
         // Valid positive parsing