Implement a flat map container for JSON objects (#1352)

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

src/json/CMakeLists.txt

@@ -1,6 +1,6 @@
 noa_library(NAMESPACE sourcemeta PROJECT jsontoolkit NAME json
   FOLDER "JSON Toolkit/JSON"
-  PRIVATE_HEADERS array.h error.h object.h value.h hash.h
+  PRIVATE_HEADERS array.h error.h object.h value.h hash.h flat_map.h
   SOURCES grammar.h parser.h stringify.h json.cc json_value.cc)
 
 if(JSONTOOLKIT_INSTALL)

src/json/include/sourcemeta/jsontoolkit/json_flat_map.h

@@ -0,0 +1,235 @@
+#ifndef SOURCEMETA_JSONTOOLKIT_JSON_FLAT_MAP_H_
+#define SOURCEMETA_JSONTOOLKIT_JSON_FLAT_MAP_H_
+
+#include <algorithm>        // std::swap
+#include <cassert>          // assert
+#include <cstddef>          // std::size_t
+#include <functional>       // std::hash
+#include <initializer_list> // std::initializer_list
+#include <iterator>         // std::advance
+#include <utility>          // std::pair, std::move
+#include <vector>           // std::vector
+
+namespace sourcemeta::jsontoolkit {
+
+/// @ingroup json
+template <typename Key, typename Value, typename Hash = std::hash<Key>>
+class FlatMap {
+public:
+  FlatMap() = default;
+
+  using key_type = Key;
+  using mapped_type = Value;
+  using value_type = std::pair<Key, Value>;
+  using underlying_type = std::vector<value_type>;
+  using size_type = typename underlying_type::size_type;
+  using difference_type = typename underlying_type::difference_type;
+  using allocator_type = typename underlying_type::allocator_type;
+  using reference = typename underlying_type::reference;
+  using const_reference = typename underlying_type::const_reference;
+  using pointer = typename underlying_type::pointer;
+  using const_pointer = typename underlying_type::const_pointer;
+  using const_iterator = typename underlying_type::const_iterator;
+  using hash_type = std::size_t;
+
+  FlatMap(std::initializer_list<value_type> entries) {
+    this->hashes.reserve(entries.size());
+    this->data.reserve(entries.size());
+    for (auto &&entry : entries) {
+      this->assign(std::move(entry.first), std::move(entry.second));
+    }
+  }
+
+  auto begin() const noexcept -> const_iterator { return this->data.begin(); }
+  auto end() const noexcept -> const_iterator { return this->data.end(); }
+  auto cbegin() const noexcept -> const_iterator { return this->data.cbegin(); }
+  auto cend() const noexcept -> const_iterator { return this->data.cend(); }
+
+  inline auto hash(const key_type &key) const noexcept -> hash_type {
+    return this->hasher(key);
+  }
+
+  // TODO: Add an assign overload for const key, rvalue
+
+  auto assign(key_type &&key, mapped_type &&value) -> hash_type {
+    assert(this->data.size() == this->hashes.size());
+    const auto key_hash{this->hash(key)};
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        this->data[index].second = std::move(value);
+        return key_hash;
+      }
+    }
+
+    // TODO: Make sure we either emplace both, or none
+    this->data.emplace_back(std::move(key), std::move(value));
+    this->hashes.emplace_back(key_hash);
+    return key_hash;
+  }
+
+  auto assign(const key_type &key, const mapped_type &value) -> hash_type {
+    assert(this->data.size() == this->hashes.size());
+    const auto key_hash{this->hash(key)};
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        this->data[index].second = value;
+        return key_hash;
+      }
+    }
+
+    // TODO: Make sure we either emplace both, or none
+    this->data.emplace_back(key, value);
+    this->hashes.emplace_back(key_hash);
+    return key_hash;
+  }
+
+  // As a performance optimisation if the hash is known
+  inline auto find(const key_type &key, const hash_type key_hash) const
+      -> const_iterator {
+    assert(this->data.size() == this->hashes.size());
+    assert(this->hash(key) == key_hash);
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        auto iterator{this->cbegin()};
+        std::advance(iterator, index);
+        return iterator;
+      }
+    }
+
+    return this->cend();
+  }
+
+  inline auto find(const key_type &key) const -> const_iterator {
+    return this->find(key, this->hash(key));
+  }
+
+  // As a performance optimisation if the hash is known
+  inline auto contains(const key_type &key, const hash_type key_hash) const
+      -> bool {
+    assert(this->data.size() == this->hashes.size());
+    assert(this->hash(key) == key_hash);
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  inline auto contains(const key_type &key) const -> bool {
+    return this->contains(key, this->hash(key));
+  }
+
+  // As a performance optimisation if the hash is known
+
+  inline auto at(const key_type &key, const hash_type key_hash) const
+      -> const mapped_type & {
+    assert(this->data.size() == this->hashes.size());
+    assert(this->hash(key) == key_hash);
+
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        return this->data[index].second;
+      }
+    }
+
+// See https://en.cppreference.com/w/cpp/utility/unreachable
+#if defined(_MSC_VER) && !defined(__clang__)
+    __assume(false);
+#else
+    __builtin_unreachable();
+#endif
+  }
+
+  inline auto at(const key_type &key, const hash_type key_hash)
+      -> mapped_type & {
+    assert(this->data.size() == this->hashes.size());
+    assert(this->hash(key) == key_hash);
+
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        return this->data[index].second;
+      }
+    }
+
+// See https://en.cppreference.com/w/cpp/utility/unreachable
+#if defined(_MSC_VER) && !defined(__clang__)
+    __assume(false);
+#else
+    __builtin_unreachable();
+#endif
+  }
+
+  inline auto at(const key_type &key) const -> const mapped_type & {
+    return this->at(key, this->hash(key));
+  }
+
+  inline auto at(const key_type &key) -> mapped_type & {
+    return this->at(key, this->hash(key));
+  }
+
+  auto erase(const key_type &key, const hash_type key_hash) -> size_type {
+    const auto current_size{this->size()};
+    for (size_type index = 0; index < current_size; index++) {
+      if (this->hashes[index] == key_hash && this->data[index].first == key) {
+        std::swap(this->hashes[index], this->hashes.back());
+        std::swap(this->data[index], this->data.back());
+        this->hashes.pop_back();
+        this->data.pop_back();
+        return current_size - 1;
+      }
+    }
+
+    return current_size;
+  }
+
+  inline auto erase(const key_type &key) -> size_type {
+    return this->erase(key, this->hash(key));
+  }
+
+  inline auto size() const noexcept -> size_type {
+    assert(this->data.size() == this->hashes.size());
+    return this->data.size();
+  }
+
+  inline auto empty() const noexcept -> bool {
+    assert(this->data.size() == this->hashes.size());
+    return this->data.empty();
+  }
+
+  inline auto clear() noexcept -> void {
+    this->data.clear();
+    this->hashes.clear();
+  }
+
+  auto operator!=(const FlatMap &other) const -> bool = default;
+
+  auto operator==(const FlatMap &other) const -> bool {
+    if (this->size() != other.size()) {
+      return false;
+    }
+
+    for (size_type index = 0; index < this->hashes.size(); index++) {
+      const auto iterator{
+          other.find(this->data[index].first, this->hashes[index])};
+      if (iterator == other.cend()) {
+        return false;
+      } else if (iterator->second != this->data[index].second) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+private:
+  underlying_type data;
+  // So that we can loop over hashes faster, potentially vectorizing loops
+  std::vector<hash_type> hashes;
+  Hash hasher;
+};
+
+} // namespace sourcemeta::jsontoolkit
+
+#endif

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

@@ -4,29 +4,15 @@
 #include <functional>       // std::equal_to, std::less
 #include <initializer_list> // std::initializer_list
 
-#if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 12)
-#include <map> // std::map
-#else
-#include <unordered_map> // std::unordered_map
-#endif
+#include <sourcemeta/jsontoolkit/json_flat_map.h>
 
 namespace sourcemeta::jsontoolkit {
 
 /// @ingroup json
 template <typename Key, typename Value, typename Hash> class JSONObject {
 public:
   // Constructors
-
-  // Older versions of GCC don't allow `std::unordered_map` to incomplete
-  // types, and in this case, `Value` is an incomplete type.
-  using Container =
-#if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 12)
-      std::map<Key, Value, std::less<Key>,
-#else
-      std::unordered_map<Key, Value, Hash, std::equal_to<Key>,
-#endif
-               typename Value::template Allocator<
-                   std::pair<const typename Value::String, Value>>>;
+  using Container = FlatMap<Key, Value, Hash>;
 
   JSONObject() : data{} {}
   JSONObject(std::initializer_list<typename Container::value_type> values)
@@ -92,16 +78,24 @@ template <typename Key, typename Value, typename Hash> class JSONObject {
   using const_pointer = typename Container::const_pointer;
   using const_iterator = typename Container::const_iterator;
 
-  auto begin() const noexcept -> const_iterator { return this->data.begin(); }
+  inline auto begin() const noexcept -> const_iterator {
+    return this->data.begin();
+  }
   /// Get a constant end iterator on the object
-  auto end() const noexcept -> const_iterator { return this->data.end(); }
+  inline auto end() const noexcept -> const_iterator {
+    return this->data.end();
+  }
   /// Get a constant begin iterator on the object
-  auto cbegin() const noexcept -> const_iterator { return this->data.cbegin(); }
+  inline auto cbegin() const noexcept -> const_iterator {
+    return this->data.cbegin();
+  }
   /// Get a constant end iterator on the object
-  auto cend() const noexcept -> const_iterator { return this->data.cend(); }
+  inline auto cend() const noexcept -> const_iterator {
+    return this->data.cend();
+  }
 
   /// Attempt to find an entry by key
-  auto find(const Key &key) const -> const_iterator {
+  inline auto find(const Key &key) const -> const_iterator {
     return this->data.find(key);
   }
 

src/json/json_value.cc

@@ -320,13 +320,13 @@ auto JSON::operator-=(const JSON &substractive) -> JSON & {
 [[nodiscard]] auto JSON::at(const JSON::String &key) const -> const JSON & {
   assert(this->is_object());
   assert(this->defines(key));
-  return std::get<Object>(this->data).data.find(key)->second;
+  return std::get<Object>(this->data).data.at(key);
 }
 
 [[nodiscard]] auto JSON::at(const JSON::String &key) -> JSON & {
   assert(this->is_object());
   assert(this->defines(key));
-  return std::get<Object>(this->data).data.find(key)->second;
+  return std::get<Object>(this->data).data.at(key);
 }
 
 [[nodiscard]] auto JSON::front() -> JSON & {
@@ -506,8 +506,7 @@ auto JSON::operator-=(const JSON &substractive) -> JSON & {
 
 [[nodiscard]] auto JSON::defines(const JSON::String &key) const -> bool {
   assert(this->is_object());
-  return std::get<Object>(this->data).find(key) !=
-         std::get<Object>(this->data).cend();
+  return std::get<Object>(this->data).data.contains(key);
 }
 
 [[nodiscard]] auto
@@ -592,12 +591,12 @@ auto JSON::push_back_if_unique(JSON &&value)
 
 auto JSON::assign(const JSON::String &key, const JSON &value) -> void {
   assert(this->is_object());
-  std::get<Object>(this->data).data.insert_or_assign(key, value);
+  std::get<Object>(this->data).data.assign(key, value);
 }
 
 auto JSON::assign(const JSON::String &key, JSON &&value) -> void {
   assert(this->is_object());
-  std::get<Object>(this->data).data.insert_or_assign(key, std::move(value));
+  std::get<Object>(this->data).data.assign(key, std::move(value));
 }
 
 auto JSON::assign_if_missing(const JSON::String &key, const JSON &value)

test/json/CMakeLists.txt

@@ -2,6 +2,7 @@ add_executable(sourcemeta_jsontoolkit_json_unit
   json_array_test.cc
   json_boolean_test.cc
   json_error_test.cc
+  json_flat_map_test.cc
   json_integer_test.cc
   json_null_test.cc
   json_number_test.cc