Fixed dot string comparisons, and introduced natural ordering.

There is some work to be done to extend strnatcmp to support view comparisons and not just null terminated strings.
For now, a suboptimal implementation of the dot comparison based on natural ordering has been implemented, requiring memory allocations.

Author: KaruroChori

RELEASE.md

@@ -1,5 +1,10 @@
 ## v0.4.3
 
+### New features
+
+- Natural ordering for strings is now supported
+
 ### Breaking
 
 - `s:enable` has been reworked as an overload of `s:when`.
+- Default string comparisons are now following natural ordering.

include/utils.hpp

@@ -50,6 +50,15 @@ inline bool cexpr_streqv(const char* s, const char* c){return strcmp(s, c)==0;}
  */
 int cmp_dot_str(const char* a, const char* b);
 
+/**
+ * @brief Compare two strings (natural comparison) assuming the dot notation for ordering nested fields
+ * 
+ * @param a 
+ * @param b 
+ * @return int 
+ */
+int cmp_dot_natstr(const char* a, const char* b);
+
 //TODO: Add natural ordering
 
 namespace hash{

meson.build

@@ -33,7 +33,7 @@ vs_templ_lib = library(
     'src/logging.cpp',
     'src/stack-lang.cpp',
   ],
-  dependencies: [pugixml_dep, frozen_dep, ff_dep],
+  dependencies: [pugixml_dep, frozen_dep, ff_dep, natsort_dep],
   include_directories: ['include'],
   install: not meson.is_subproject(),
 )

src/utils.cpp

@@ -1,4 +1,5 @@
 #include <utils.hpp>
+#include <strnatcmp.h>
 
 namespace vs{
 namespace templ{
@@ -21,13 +22,32 @@ int cmp_dot_str(const char* a, const char* b){
     if(va.size()<vb.size())return -1;
     else if(va.size()>vb.size())return 1;
 
-    for(size_t i =0;i<va.size();i++){
+    for(size_t i=0;i<va.size();i++){
         if(va.at(i)<vb.at(i))return -1;
         else if(va.at(i)>vb.at(i))return 1;
     }
-    return -1;
+    return 0;
 }
 
+int cmp_dot_natstr(const char* a, const char* b){
+    auto va = split_string(a, '.');
+    auto vb = split_string(b, '.');
+
+    if(va.size()<vb.size())return -1;
+    else if(va.size()>vb.size())return 1;
+
+    for(size_t i=0;i<va.size();i++){
+        //TODO: Implement the view version of strnatcmp, otherwise I am forced to perform these bad allocations
+        std::string a = std::string(va.at(i));
+        std::string b = std::string(vb.at(i));
+        auto ret = strnatcmp(a.c_str(),b.c_str());
+        if(ret<0)return -1;
+        else if(ret>0)return 1;
+    }
+    return 0;
+}
+
+
 namespace hash{
 
 #if defined(_MSC_VER)

src/vs-templ.cpp

@@ -3,6 +3,7 @@
 #include <string_view>
 #include <variant>
 #include <format>
+#include <strnatcmp.h>
 
 #if (defined(__GNUC__) && __GNUC__ >= 13) || (defined(__clang__) && __clang_major__ >= 20) ||  (defined(_MSC_VER) &&  _MSC_VER >= 1910)
 #include <charconv>
@@ -54,7 +55,7 @@ preprocessor::compare_result preprocessor::compare_symbols(const symbol& a, cons
     if(method.type==order_t::type_t::DEFAULT){
         if(std::holds_alternative<int>(a))method.type=order_t::type_t::INTEGER;
         else if(std::holds_alternative<float>(a))method.type=order_t::type_t::FLOAT;
-        else if(std::holds_alternative<std::string>(a))method.type=order_t::type_t::STRING;//TODO: move to `order_t::type_t::NATURAL_STRING`
+        else if(std::holds_alternative<std::string>(a))method.type=order_t::type_t::NATURAL_STRING;
         else if(std::holds_alternative<const pugi::xml_node>(a))method.type=order_t::type_t::NODE;
     }
 
@@ -79,12 +80,11 @@ preprocessor::compare_result preprocessor::compare_symbols(const symbol& a, cons
     else if(std::holds_alternative<const pugi::xml_node>(a) && std::holds_alternative<const pugi::xml_node>(b) && method.type==order_t::type_t::NODE){
 
     }
-    else if(std::holds_alternative<std::string>(a) && std::holds_alternative<std::string>(b) && method.type==order_t::type_t::STRING){
+    else if(std::holds_alternative<std::string>(a) && std::holds_alternative<std::string>(b) && (method.type==order_t::type_t::STRING || method.type==order_t::type_t::NATURAL_STRING ) ){
         const auto& _a = std::get<std::string>(a), _b = std::get<std::string>(b);
         if(method.modifiers.dot){
-            auto i = cmp_dot_str(_a.c_str(), _b.c_str());
-            if(method.method==order_t::method_t::ASC) return (i<0)?compare_result::LESS: ( (i>0)? compare_result::BIGGER : compare_result::EQUAL);
-            else if(method.method==order_t::method_t::DESC) return (i<0)?compare_result::BIGGER: ( (i>0)? compare_result::LESS : compare_result::EQUAL);
+            if(method.method==order_t::method_t::ASC){auto i = (method.type==order_t::type_t::NATURAL_STRING)?cmp_dot_natstr(_a.c_str(), _b.c_str()):cmp_dot_str(_a.c_str(), _b.c_str());return (i<0)?compare_result::LESS: ( (i>0)? compare_result::BIGGER : compare_result::EQUAL);}
+            else if(method.method==order_t::method_t::DESC){auto i = -((method.type==order_t::type_t::NATURAL_STRING)?cmp_dot_natstr(_a.c_str(), _b.c_str()):cmp_dot_str(_a.c_str(), _b.c_str())); return (i<0)?compare_result::LESS: ( (i>0)? compare_result::BIGGER : compare_result::EQUAL);}
             else if(method.method==order_t::method_t::RANDOM){
                 auto va = split_string(std::get<std::string>(a).c_str(), '.');
                 auto vb = split_string(std::get<std::string>(b).c_str(), '.');
@@ -106,8 +106,8 @@ preprocessor::compare_result preprocessor::compare_symbols(const symbol& a, cons
             }
         }
         else{
-            if(method.method==order_t::method_t::ASC) return (_a<_b)?compare_result::LESS: ( (_a>_b)? compare_result::BIGGER : compare_result::EQUAL);
-            else if(method.method==order_t::method_t::DESC) return (_a<_b)?compare_result::BIGGER: ( (_a>_b)? compare_result::LESS : compare_result::EQUAL);
+            if(method.method==order_t::method_t::ASC){auto cmp = (method.type==order_t::type_t::NATURAL_STRING)?strnatcmp(_a.c_str(),_b.c_str()):strcmp(_a.c_str(),_b.c_str()); return (cmp<0)?compare_result::LESS: ( (cmp>0)? compare_result::BIGGER : compare_result::EQUAL);}
+            else if(method.method==order_t::method_t::DESC){auto cmp = -((method.type==order_t::type_t::NATURAL_STRING)?strnatcmp(_a.c_str(),_b.c_str()):strcmp(_a.c_str(),_b.c_str())); return (cmp<0)?compare_result::LESS: ( (cmp>0)? compare_result::BIGGER : compare_result::EQUAL);}
             else if(method.method==order_t::method_t::RANDOM){
                 auto hash_a = preprocessor::hash(a);
                 auto hash_b = preprocessor::hash(b);
@@ -116,10 +116,7 @@ preprocessor::compare_result preprocessor::compare_symbols(const symbol& a, cons
         } 
     }
     else if(std::holds_alternative<std::string>(a) && std::holds_alternative<std::string>(b) && method.type==order_t::type_t::LEXI_STRING){
-        
-    }
-    else if(std::holds_alternative<std::string>(a) && std::holds_alternative<std::string>(b) && method.type==order_t::type_t::NATURAL_STRING){
-        //https://github.com/sourcefrog/natsort
+        //TODO: not implemented
     }
     //Cannot have pugi::xml_attribute since it has been resolved by the time it gets here.