From ef2ef6d7aabd877a22c73df416570b673c58023f Mon Sep 17 00:00:00 2001
From: "Zheng, Lei" <realthunder.dev@gmail.com>
Date: Mon, 15 Jan 2024 21:22:57 -0600
Subject: [PATCH] App/Toponaming: Add Comparator for mapped elements

This is the original code from the Toponaming branch, modified slightly to update the
method name and correct some grammatical errors in the descriptive comment.

Co-authored-by: Chris Hennes <chennes@pioneerlibrarysystem.org>
---
 src/App/MappedElement.cpp | 102 ++++++++++++++++++++++++++++++++++++++
 src/App/MappedElement.h   |  16 ++++++
 2 files changed, 118 insertions(+)

diff --git a/src/App/MappedElement.cpp b/src/App/MappedElement.cpp
index 14eb6f99ba..5df937adfe 100644
--- a/src/App/MappedElement.cpp
+++ b/src/App/MappedElement.cpp
@@ -22,3 +22,105 @@
 
 #include "PreCompiled.h"
 #include "MappedElement.h"
+
+using namespace Data;
+
+bool ElementNameComparator::operator()(const MappedName &a, const MappedName &b) const {
+    size_t size = std::min(a.size(),b.size());
+    if(!size)
+        return a.size()<b.size();
+    size_t i=0;
+    if(b[0] == '#') {
+        if(a[0]!='#')
+            return true;
+        // If both string starts with '#', compare the following hex digits by
+        // its integer value.
+        int res = 0;
+        for(i=1;i<size;++i) {
+            unsigned char ac = (unsigned char)a[i];
+            unsigned char bc = (unsigned char)b[i];
+            if(std::isxdigit(bc)) {
+                if(!std::isxdigit(ac))
+                    return true;
+                if(res==0) {
+                    if(ac<bc)
+                        res = -1;
+                    else if(ac>bc)
+                        res = 1;
+                }
+            }else if(std::isxdigit(ac))
+                return false;
+            else
+                break;
+        }
+        if(res < 0)
+            return true;
+        else if(res > 0)
+            return false;
+
+        for (; i<size; ++i) {
+            char ac = a[i];
+            char bc = b[i];
+            if (ac < bc)
+                return true;
+            if (ac > bc)
+                return false;
+        }
+        return a.size()<b.size();
+    }
+    else if (a[0] == '#')
+        return false;
+
+    // If the string does not start with '#', compare the non-digits prefix
+    // using lexical order.
+    for(i=0;i<size;++i) {
+        unsigned char ac = (unsigned char)a[i];
+        unsigned char bc = (unsigned char)b[i];
+        if(!std::isdigit(bc)) {
+            if(std::isdigit(ac))
+                return true;
+            if(ac<bc)
+                return true;
+            if(ac>bc)
+                return false;
+        } else if(!std::isdigit(ac)) {
+            return false;
+        } else
+            break;
+    }
+
+    // Then compare the following digits part by integer value
+    int res = 0;
+    for(;i<size;++i) {
+        unsigned char ac = (unsigned char)a[i];
+        unsigned char bc = (unsigned char)b[i];
+        if(std::isdigit(bc)) {
+            if(!std::isdigit(ac))
+                return true;
+            if(res==0) {
+                if(ac<bc)
+                    res = -1;
+                else if(ac>bc)
+                    res = 1;
+            }
+        }else if(std::isdigit(ac))
+            return false;
+        else
+            break;
+    }
+    if(res < 0)
+        return true;
+    else if(res > 0)
+        return false;
+
+    // Finally, compare the remaining tail using lexical order
+    for (; i<size; ++i) {
+        char ac = a[i];
+        char bc = b[i];
+        if (ac < bc)
+            return true;
+        if (ac > bc)
+            return false;
+    }
+    return a.size()<b.size();
+}
\ No newline at end of file
diff --git a/src/App/MappedElement.h b/src/App/MappedElement.h
index 7f6ee68f01..9c37c3e8ba 100644
--- a/src/App/MappedElement.h
+++ b/src/App/MappedElement.h
@@ -98,6 +98,22 @@ struct AppExport MappedElement
     }
 };
 
+struct AppExport ElementNameComparator {
+    /** Comparison function to make topo name more stable
+     *
+     * The sorting decomposes the name into either of the following two forms
+     *      '#' + hex_digits + tail
+     *      non_digits + digits + tail
+     *
+     * The non-digits part is compared lexically, while the digits part is
+     * compared by its integer value.
+     *
+     * The reason for this is to prevent names with bigger digits (which usually means
+     * they come later in history) from coming earlier when sorting.
+     */
+    bool operator()(const MappedName &a, const MappedName &b) const;
+};
+
 }// namespace Data