Implement a JSON::try_emplace_before method

Fixes: #1828
Signed-off-by: Juan Cruz Viotti <[email protected]>

Author: jviotti

src/core/json/include/sourcemeta/core/json_object.h

@@ -78,6 +78,39 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
     return key_hash;
   }
 
+  auto try_emplace_before(const key_type &key, const mapped_type &value,
+                          const key_type &suffix) -> hash_type {
+    const auto key_hash{this->hash(key)};
+    const auto suffix_hash{this->hash(suffix)};
+
+    if (this->hasher.is_perfect(key_hash)) {
+      for (auto iterator = this->data.begin(); iterator != this->data.end();
+           ++iterator) {
+        if (iterator->hash == key_hash) {
+          iterator->second = value;
+          return key_hash;
+        } else if (iterator->hash == suffix_hash && iterator->first == suffix) {
+          this->data.insert(iterator, {key, value, key_hash});
+          return key_hash;
+        }
+      }
+    } else {
+      for (auto iterator = this->data.begin(); iterator != this->data.end();
+           ++iterator) {
+        if (iterator->hash == key_hash && iterator->first == key) {
+          iterator->second = value;
+          return key_hash;
+        } else if (iterator->hash == suffix_hash && iterator->first == suffix) {
+          this->data.insert(iterator, {key, value, key_hash});
+          return key_hash;
+        }
+      }
+    }
+
+    this->data.push_back({key, value, key_hash});
+    return key_hash;
+  }
+
   auto emplace(const key_type &key, const mapped_type &value) -> hash_type {
     const auto key_hash{this->hash(key)};
 

src/core/json/include/sourcemeta/core/json_value.h

@@ -1291,6 +1291,22 @@ class SOURCEMETA_CORE_JSON_EXPORT JSON {
   /// ```
   auto assign(const String &key, JSON &&value) -> void;
 
+  /// This method sets or updates an object key. However, it will try to insert
+  /// the key _before_ the given one if possible.
+  ///
+  /// ```cpp
+  /// #include <sourcemeta/core/json.h>
+  /// #include <cassert>
+  ///
+  /// sourcemeta::core::JSON document =
+  ///   sourcemeta::core::parse_json("{ \"foo\": true }");
+  /// const sourcemeta::core::JSON value{false};
+  /// document.try_assign_before("bar", value, "foo");
+  /// assert(document.as_object().cbegin()->first == "bar");
+  /// ```
+  auto try_assign_before(const String &key, const JSON &value,
+                         const String &other) -> void;
+
   /// This method sets an object key if it is not already defined. For example:
   ///
   /// ```cpp

src/core/json/json_value.cc

@@ -809,6 +809,12 @@ auto JSON::assign(const JSON::String &key, JSON &&value) -> void {
   this->data_object.data.emplace(key, value);
 }
 
+auto JSON::try_assign_before(const String &key, const JSON &value,
+                             const String &other) -> void {
+  assert(this->is_object());
+  this->data_object.data.try_emplace_before(key, value, other);
+}
+
 auto JSON::assign_if_missing(const JSON::String &key, const JSON &value)
     -> void {
   assert(this->is_object());

test/json/json_object_test.cc

@@ -862,3 +862,81 @@ TEST(JSON_object, at_or_not_defined_with_hash) {
   EXPECT_TRUE(result.is_integer());
   EXPECT_EQ(result.to_integer(), 99);
 }
+
+TEST(JSON_object, try_assign_before_exists) {
+  sourcemeta::core::JSON document{{"foo", sourcemeta::core::JSON{1}},
+                                  {"bar", sourcemeta::core::JSON{2}}};
+
+  document.try_assign_before("baz", sourcemeta::core::JSON{99}, "bar");
+
+  std::vector<sourcemeta::core::JSON::String> properties;
+  for (const auto &entry : document.as_object()) {
+    properties.emplace_back(entry.first);
+  }
+
+  EXPECT_EQ(properties.size(), 3);
+  EXPECT_EQ(properties.at(0), "foo");
+  EXPECT_EQ(properties.at(1), "baz");
+  EXPECT_EQ(properties.at(2), "bar");
+
+  EXPECT_EQ(document.at("foo").to_integer(), 1);
+  EXPECT_EQ(document.at("bar").to_integer(), 2);
+  EXPECT_EQ(document.at("baz").to_integer(), 99);
+}
+
+TEST(JSON_object, try_assign_before_not_exists) {
+  sourcemeta::core::JSON document{{"foo", sourcemeta::core::JSON{1}},
+                                  {"bar", sourcemeta::core::JSON{2}}};
+
+  document.try_assign_before("baz", sourcemeta::core::JSON{99}, "qux");
+
+  std::vector<sourcemeta::core::JSON::String> properties;
+  for (const auto &entry : document.as_object()) {
+    properties.emplace_back(entry.first);
+  }
+
+  EXPECT_EQ(properties.size(), 3);
+  EXPECT_EQ(properties.at(0), "foo");
+  EXPECT_EQ(properties.at(1), "bar");
+  EXPECT_EQ(properties.at(2), "baz");
+
+  EXPECT_EQ(document.at("foo").to_integer(), 1);
+  EXPECT_EQ(document.at("bar").to_integer(), 2);
+  EXPECT_EQ(document.at("baz").to_integer(), 99);
+}
+
+TEST(JSON_object, try_assign_before_exists_front) {
+  sourcemeta::core::JSON document{{"foo", sourcemeta::core::JSON{1}},
+                                  {"bar", sourcemeta::core::JSON{2}}};
+
+  document.try_assign_before("baz", sourcemeta::core::JSON{99}, "foo");
+
+  std::vector<sourcemeta::core::JSON::String> properties;
+  for (const auto &entry : document.as_object()) {
+    properties.emplace_back(entry.first);
+  }
+
+  EXPECT_EQ(properties.size(), 3);
+  EXPECT_EQ(properties.at(0), "baz");
+  EXPECT_EQ(properties.at(1), "foo");
+  EXPECT_EQ(properties.at(2), "bar");
+
+  EXPECT_EQ(document.at("foo").to_integer(), 1);
+  EXPECT_EQ(document.at("bar").to_integer(), 2);
+  EXPECT_EQ(document.at("baz").to_integer(), 99);
+}
+
+TEST(JSON_object, try_assign_before_empty) {
+  sourcemeta::core::JSON document{sourcemeta::core::JSON::make_object()};
+
+  document.try_assign_before("baz", sourcemeta::core::JSON{99}, "foo");
+
+  std::vector<sourcemeta::core::JSON::String> properties;
+  for (const auto &entry : document.as_object()) {
+    properties.emplace_back(entry.first);
+  }
+
+  EXPECT_EQ(properties.size(), 1);
+  EXPECT_EQ(properties.at(0), "baz");
+  EXPECT_EQ(document.at("baz").to_integer(), 99);
+}