Skip to content

Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences

Infix basics.

Kishore Nallanba101d0b4034
diff --git a/CMakeLists.txt b/CMakeLists.txt
index deea2f5c..d0b038bc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,6 +89,7 @@ FILE(GLOB SRC_FILES src/*.cpp ${DEP_ROOT_DIR}/${KAKASI_NAME}/data/*.cpp)
FILE(GLOB TEST_FILES test/*.cpp)
include_directories(include)
+include_directories(include/tsl)
include_directories(/usr/local/include)
include_directories(${OPENSSL_INCLUDE_DIR})
include_directories(${CURL_INCLUDE_DIR})
diff --git a/include/collection.h b/include/collection.h
index 28d45334..69046a86 100644
--- a/include/collection.h
+++ b/include/collection.h
@@ -395,7 +395,10 @@ public:
size_t min_len_1typo = 4,
size_t min_len_2typo = 7,
bool split_join_tokens = true,
- size_t max_candidates = 4) const;
+ size_t max_candidates = 4,
+ const std::vector<infix_t>& infixes = {off},
+ const size_t max_extra_prefix = INT16_MAX,
+ const size_t max_extra_suffix = INT16_MAX) const;
Option<bool> get_filter_ids(const std::string & simple_filter_query,
std::vector<std::pair<size_t, uint32_t*>>& index_ids);
diff --git a/include/field.h b/include/field.h
index 0102e7b1..f6753af8 100644
--- a/include/field.h
+++ b/include/field.h
@@ -38,6 +38,7 @@ namespace fields {
static const std::string optional = "optional";
static const std::string index = "index";
static const std::string sort = "sort";
+ static const std::string infix = "infix";
static const std::string locale = "locale";
}
@@ -49,9 +50,10 @@ struct field {
bool index;
std::string locale;
bool sort;
+ bool infix;
field(const std::string &name, const std::string &type, const bool facet, const bool optional = false,
- bool index = true, std::string locale = "", int sort = -1) :
+ bool index = true, std::string locale = "", int sort = -1, int infix = -1) :
name(name), type(type), facet(facet), optional(optional), index(index), locale(locale) {
if(sort != -1) {
@@ -59,6 +61,8 @@ struct field {
} else {
this->sort = is_num_sort_field();
}
+
+ this->infix = (infix != -1) ? bool(infix) : false;
}
bool is_auto() const {
@@ -361,6 +365,11 @@ struct field {
field_json[fields::name].get<std::string>() + std::string("` should be a boolean."));
}
+ if(field_json.count(fields::infix) != 0 && !field_json.at(fields::infix).is_boolean()) {
+ return Option<bool>(400, std::string("The `infix` property of the field `") +
+ field_json[fields::name].get<std::string>() + std::string("` should be a boolean."));
+ }
+
if(field_json.count(fields::locale) != 0){
if(!field_json.at(fields::locale).is_string()) {
return Option<bool>(400, std::string("The `locale` property of the field `") +
@@ -395,6 +404,10 @@ struct field {
field_json[fields::sort] = false;
}
+ if(field_json.count(fields::infix) == 0) {
+ field_json[fields::infix] = false;
+ }
+
if(field_json[fields::optional] == false) {
return Option<bool>(400, "Field `.*` must be an optional field.");
}
@@ -409,7 +422,7 @@ struct field {
field fallback_field(field_json["name"], field_json["type"], field_json["facet"],
field_json["optional"], field_json[fields::index], field_json[fields::locale],
- field_json[fields::sort]);
+ field_json[fields::sort], field_json[fields::infix]);
if(fallback_field.has_valid_type()) {
fallback_field_type = fallback_field.type;
@@ -444,6 +457,10 @@ struct field {
}
}
+ if(field_json.count(fields::infix) == 0) {
+ field_json[fields::infix] = false;
+ }
+
if(field_json.count(fields::optional) == 0) {
// dynamic fields are always optional
bool is_dynamic = field::is_dynamic(field_json[fields::name], field_json[fields::type]);
@@ -453,7 +470,7 @@ struct field {
fields.emplace_back(
field(field_json[fields::name], field_json[fields::type], field_json[fields::facet],
field_json[fields::optional], field_json[fields::index], field_json[fields::locale],
- field_json[fields::sort])
+ field_json[fields::sort], field_json[fields::infix])
);
}
diff --git a/include/index.h b/include/index.h
index af1bf097..db43a6da 100644
--- a/include/index.h
+++ b/include/index.h
@@ -22,11 +22,15 @@
#include "posting_list.h"
#include "threadpool.h"
#include "adi_tree.h"
+#include "tsl/htrie_set.h"
static constexpr size_t ARRAY_FACET_DIM = 4;
using facet_map_t = spp::sparse_hash_map<uint32_t, facet_hash_values_t>;
using array_mapped_facet_t = std::array<facet_map_t*, ARRAY_FACET_DIM>;
+static constexpr size_t ARRAY_INFIX_DIM = 4;
+using array_mapped_infix_t = std::vector<tsl::htrie_set<char>*>;
+
struct token_t {
size_t position;
std::string value;
@@ -258,6 +262,12 @@ struct override_t {
}
};
+enum infix_t {
+ always,
+ fallback,
+ off
+};
+
struct search_args {
std::vector<query_tokens_t> field_query_tokens;
std::vector<search_field_t> search_fields;
@@ -287,6 +297,9 @@ struct search_args {
size_t min_len_1typo;
size_t min_len_2typo;
size_t max_candidates;
+ std::vector<infix_t> infixes;
+ const size_t max_extra_prefix;
+ const size_t max_extra_suffix;
spp::sparse_hash_set<uint64_t> groups_processed;
std::vector<std::vector<art_leaf*>> searched_queries;
@@ -312,7 +325,10 @@ struct search_args {
size_t search_cutoff_ms,
size_t min_len_1typo,
size_t min_len_2typo,
- size_t max_candidates):
+ size_t max_candidates,
+ const std::vector<infix_t>& infixes,
+ const size_t max_extra_prefix,
+ const size_t max_extra_suffix):
field_query_tokens(field_query_tokens),
search_fields(search_fields), filters(filters), facets(facets),
included_ids(included_ids), excluded_ids(excluded_ids), sort_fields_std(sort_fields_std),
@@ -323,7 +339,8 @@ struct search_args {
prioritize_exact_match(prioritize_exact_match), all_result_ids_len(0),
exhaustive_search(exhaustive_search), concurrency(concurrency),
filter_overrides(dynamic_overrides), search_cutoff_ms(search_cutoff_ms),
- min_len_1typo(min_len_1typo), min_len_2typo(min_len_2typo), max_candidates(max_candidates) {
+ min_len_1typo(min_len_1typo), min_len_2typo(min_len_2typo), max_candidates(max_candidates),
+ infixes(infixes), max_extra_prefix(max_extra_prefix), max_extra_suffix(max_extra_suffix) {
const size_t topster_size = std::max((size_t)1, max_hits); // needs to be atleast 1 since scoring is mandatory
topster = new Topster(topster_size, group_limit);
@@ -431,6 +448,9 @@ private:
// str_sort_field => adi_tree_t
spp::sparse_hash_map<std::string, adi_tree_t*> str_sort_index;
+ // infix field => value
+ spp::sparse_hash_map<std::string, array_mapped_infix_t> infix_index;
+
// geo_array_field => (seq_id => values) used for exact filtering of geo array records
spp::sparse_hash_map<std::string, spp::sparse_hash_map<uint32_t, int64_t*>*> geo_array_index;
@@ -697,7 +717,10 @@ public:
size_t search_cutoff_ms,
size_t min_len_1typo,
size_t min_len_2typo,
- size_t max_candidates) const;
+ size_t max_candidates,
+ const std::vector<infix_t>& infixes,
+ const size_t max_extra_prefix,
+ const size_t max_extra_suffix) const;
Option<uint32_t> remove(const uint32_t seq_id, const nlohmann::json & document, const bool is_update);
@@ -758,6 +781,9 @@ public:
uint32_t*& all_result_ids, size_t& all_result_ids_len, const uint32_t* filter_ids,
uint32_t filter_ids_length, const size_t concurrency) const;
+ void search_infix(const std::string& query, const std::string& field_name, std::vector<uint32_t>& ids,
+ size_t max_extra_prefix, size_t max_extra_suffix) const;
+
void curate_filtered_ids(const std::vector<filter>& filters, const std::set<uint32_t>& curated_ids,
const uint32_t* exclude_token_ids, size_t exclude_token_ids_size, uint32_t*& filter_ids,
uint32_t& filter_ids_length, const std::vector<uint32_t>& curated_ids_sorted) const;
diff --git a/include/tsl/array-hash/array_growth_policy.h b/include/tsl/array-hash/array_growth_policy.h
new file mode 100644
index 00000000..65bba795
--- /dev/null
+++ b/include/tsl/array-hash/array_growth_policy.h
@@ -0,0 +1,296 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ARRAY_GROWTH_POLICY_H
+#define TSL_ARRAY_GROWTH_POLICY_H
+
+#include <algorithm>
+#include <array>
+#include <climits>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <ratio>
+#include <stdexcept>
+
+namespace tsl {
+namespace ah {
+
+/**
+ * Grow the hash table by a factor of GrowthFactor keeping the bucket count to a
+ * power of two. It allows the table to use a mask operation instead of a modulo
+ * operation to map a hash to a bucket.
+ *
+ * GrowthFactor must be a power of two >= 2.
+ */
+template <std::size_t GrowthFactor>
+class power_of_two_growth_policy {
+ public:
+ /**
+ * Called on the hash table creation and on rehash. The number of buckets for
+ * the table is passed in parameter. This number is a minimum, the policy may
+ * update this value with a higher value if needed (but not lower).
+ *
+ * If 0 is given, min_bucket_count_in_out must still be 0 after the policy
+ * creation and bucket_for_hash must always return 0 in this case.
+ */
+ explicit power_of_two_growth_policy(std::size_t& min_bucket_count_in_out) {
+ if (min_bucket_count_in_out > max_bucket_count()) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ if (min_bucket_count_in_out > 0) {
+ min_bucket_count_in_out =
+ round_up_to_power_of_two(min_bucket_count_in_out);
+ m_mask = min_bucket_count_in_out - 1;
+ } else {
+ m_mask = 0;
+ }
+ }
+
+ /**
+ * Return the bucket [0, bucket_count()) to which the hash belongs.
+ * If bucket_count() is 0, it must always return 0.
+ */
+ std::size_t bucket_for_hash(std::size_t hash) const noexcept {
+ return hash & m_mask;
+ }
+
+ /**
+ * Return the number of buckets that should be used on next growth.
+ */
+ std::size_t next_bucket_count() const {
+ if ((m_mask + 1) > max_bucket_count() / GrowthFactor) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ return (m_mask + 1) * GrowthFactor;
+ }
+
+ /**
+ * Return the maximum number of buckets supported by the policy.
+ */
+ std::size_t max_bucket_count() const {
+ // Largest power of two.
+ return (std::numeric_limits<std::size_t>::max() / 2) + 1;
+ }
+
+ /**
+ * Reset the growth policy as if it was created with a bucket count of 0.
+ * After a clear, the policy must always return 0 when bucket_for_hash is
+ * called.
+ */
+ void clear() noexcept { m_mask = 0; }
+
+ private:
+ static std::size_t round_up_to_power_of_two(std::size_t value) {
+ if (is_power_of_two(value)) {
+ return value;
+ }
+
+ if (value == 0) {
+ return 1;
+ }
+
+ --value;
+ for (std::size_t i = 1; i < sizeof(std::size_t) * CHAR_BIT; i *= 2) {
+ value |= value >> i;
+ }
+
+ return value + 1;
+ }
+
+ static constexpr bool is_power_of_two(std::size_t value) {
+ return value != 0 && (value & (value - 1)) == 0;
+ }
+
+ protected:
+ static_assert(is_power_of_two(GrowthFactor) && GrowthFactor >= 2,
+ "GrowthFactor must be a power of two >= 2.");
+
+ std::size_t m_mask;
+};
+
+/**
+ * Grow the hash table by GrowthFactor::num / GrowthFactor::den and use a modulo
+ * to map a hash to a bucket. Slower but it can be useful if you want a slower
+ * growth.
+ */
+template <class GrowthFactor = std::ratio<3, 2>>
+class mod_growth_policy {
+ public:
+ explicit mod_growth_policy(std::size_t& min_bucket_count_in_out) {
+ if (min_bucket_count_in_out > max_bucket_count()) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ if (min_bucket_count_in_out > 0) {
+ m_mod = min_bucket_count_in_out;
+ } else {
+ m_mod = 1;
+ }
+ }
+
+ std::size_t bucket_for_hash(std::size_t hash) const noexcept {
+ return hash % m_mod;
+ }
+
+ std::size_t next_bucket_count() const {
+ if (m_mod == max_bucket_count()) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ const double next_bucket_count =
+ std::ceil(double(m_mod) * REHASH_SIZE_MULTIPLICATION_FACTOR);
+ if (!std::isnormal(next_bucket_count)) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ if (next_bucket_count > double(max_bucket_count())) {
+ return max_bucket_count();
+ } else {
+ return std::size_t(next_bucket_count);
+ }
+ }
+
+ std::size_t max_bucket_count() const { return MAX_BUCKET_COUNT; }
+
+ void clear() noexcept { m_mod = 1; }
+
+ private:
+ static constexpr double REHASH_SIZE_MULTIPLICATION_FACTOR =
+ 1.0 * GrowthFactor::num / GrowthFactor::den;
+ static const std::size_t MAX_BUCKET_COUNT =
+ std::size_t(double(std::numeric_limits<std::size_t>::max() /
+ REHASH_SIZE_MULTIPLICATION_FACTOR));
+
+ static_assert(REHASH_SIZE_MULTIPLICATION_FACTOR >= 1.1,
+ "Growth factor should be >= 1.1.");
+
+ std::size_t m_mod;
+};
+
+namespace detail {
+
+static constexpr const std::array<std::size_t, 40> PRIMES = {
+ {1ul, 5ul, 17ul, 29ul, 37ul,
+ 53ul, 67ul, 79ul, 97ul, 131ul,
+ 193ul, 257ul, 389ul, 521ul, 769ul,
+ 1031ul, 1543ul, 2053ul, 3079ul, 6151ul,
+ 12289ul, 24593ul, 49157ul, 98317ul, 196613ul,
+ 393241ul, 786433ul, 1572869ul, 3145739ul, 6291469ul,
+ 12582917ul, 25165843ul, 50331653ul, 100663319ul, 201326611ul,
+ 402653189ul, 805306457ul, 1610612741ul, 3221225473ul, 4294967291ul}};
+
+template <unsigned int IPrime>
+static constexpr std::size_t mod(std::size_t hash) {
+ return hash % PRIMES[IPrime];
+}
+
+// MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for
+// faster modulo as the compiler can optimize the modulo code better with a
+// constant known at the compilation.
+static constexpr const std::array<std::size_t (*)(std::size_t), 40> MOD_PRIME =
+ {{&mod<0>, &mod<1>, &mod<2>, &mod<3>, &mod<4>, &mod<5>, &mod<6>,
+ &mod<7>, &mod<8>, &mod<9>, &mod<10>, &mod<11>, &mod<12>, &mod<13>,
+ &mod<14>, &mod<15>, &mod<16>, &mod<17>, &mod<18>, &mod<19>, &mod<20>,
+ &mod<21>, &mod<22>, &mod<23>, &mod<24>, &mod<25>, &mod<26>, &mod<27>,
+ &mod<28>, &mod<29>, &mod<30>, &mod<31>, &mod<32>, &mod<33>, &mod<34>,
+ &mod<35>, &mod<36>, &mod<37>, &mod<38>, &mod<39>}};
+
+} // namespace detail
+
+/**
+ * Grow the hash table by using prime numbers as bucket count. Slower than
+ * tsl::ah::power_of_two_growth_policy in general but will probably distribute
+ * the values around better in the buckets with a poor hash function.
+ *
+ * To allow the compiler to optimize the modulo operation, a lookup table is
+ * used with constant primes numbers.
+ *
+ * With a switch the code would look like:
+ * \code
+ * switch(iprime) { // iprime is the current prime of the hash table
+ * case 0: hash % 5ul;
+ * break;
+ * case 1: hash % 17ul;
+ * break;
+ * case 2: hash % 29ul;
+ * break;
+ * ...
+ * }
+ * \endcode
+ *
+ * Due to the constant variable in the modulo the compiler is able to optimize
+ * the operation by a series of multiplications, substractions and shifts.
+ *
+ * The 'hash % 5' could become something like 'hash - (hash * 0xCCCCCCCD) >> 34)
+ * * 5' in a 64 bits environment.
+ */
+class prime_growth_policy {
+ public:
+ explicit prime_growth_policy(std::size_t& min_bucket_count_in_out) {
+ auto it_prime = std::lower_bound(
+ detail::PRIMES.begin(), detail::PRIMES.end(), min_bucket_count_in_out);
+ if (it_prime == detail::PRIMES.end()) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ m_iprime = static_cast<unsigned int>(
+ std::distance(detail::PRIMES.begin(), it_prime));
+ if (min_bucket_count_in_out > 0) {
+ min_bucket_count_in_out = *it_prime;
+ } else {
+ min_bucket_count_in_out = 0;
+ }
+ }
+
+ std::size_t bucket_for_hash(std::size_t hash) const noexcept {
+ return detail::MOD_PRIME[m_iprime](hash);
+ }
+
+ std::size_t next_bucket_count() const {
+ if (m_iprime + 1 >= detail::PRIMES.size()) {
+ throw std::length_error("The hash table exceeds its maximum size.");
+ }
+
+ return detail::PRIMES[m_iprime + 1];
+ }
+
+ std::size_t max_bucket_count() const { return detail::PRIMES.back(); }
+
+ void clear() noexcept { m_iprime = 0; }
+
+ private:
+ unsigned int m_iprime;
+
+ static_assert(std::numeric_limits<decltype(m_iprime)>::max() >=
+ detail::PRIMES.size(),
+ "The type of m_iprime is not big enough.");
+};
+
+} // namespace ah
+} // namespace tsl
+
+#endif
diff --git a/include/tsl/array-hash/array_hash.h b/include/tsl/array-hash/array_hash.h
new file mode 100644
index 00000000..b639e8a4
--- /dev/null
+++ b/include/tsl/array-hash/array_hash.h
@@ -0,0 +1,1807 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ARRAY_HASH_H
+#define TSL_ARRAY_HASH_H
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "array_growth_policy.h"
+
+/*
+ * __has_include is a bit useless
+ * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79433), check also __cplusplus
+ * version.
+ */
+#ifdef __has_include
+#if __has_include(<string_view>) && __cplusplus >= 201703L
+#define TSL_AH_HAS_STRING_VIEW
+#endif
+#endif
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef TSL_DEBUG
+#define tsl_ah_assert(expr) assert(expr)
+#else
+#define tsl_ah_assert(expr) (static_cast<void>(0))
+#endif
+
+/**
+ * Implementation of the array hash structure described in the
+ * "Cache-conscious collision resolution in string hash tables." (Askitis
+ * Nikolas and Justin Zobel, 2005) paper.
+ */
+namespace tsl {
+
+namespace ah {
+
+template <class CharT>
+struct str_hash {
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::size_t operator()(const CharT* key, std::size_t key_size) const {
+ return std::hash<std::basic_string_view<CharT>>()(
+ std::basic_string_view<CharT>(key, key_size));
+ }
+#else
+ /**
+ * FNV-1a hash
+ */
+ std::size_t operator()(const CharT* key, std::size_t key_size) const {
+ static const std::size_t init = std::size_t(
+ (sizeof(std::size_t) == 8) ? 0xcbf29ce484222325 : 0x811c9dc5);
+ static const std::size_t multiplier =
+ std::size_t((sizeof(std::size_t) == 8) ? 0x100000001b3 : 0x1000193);
+
+ std::size_t hash = init;
+ for (std::size_t i = 0; i < key_size; ++i) {
+ hash ^= key[i];
+ hash *= multiplier;
+ }
+
+ return hash;
+ }
+#endif
+};
+
+template <class CharT>
+struct str_equal {
+ bool operator()(const CharT* key_lhs, std::size_t key_size_lhs,
+ const CharT* key_rhs, std::size_t key_size_rhs) const {
+ if (key_size_lhs != key_size_rhs) {
+ return false;
+ } else {
+ return std::memcmp(key_lhs, key_rhs, key_size_lhs * sizeof(CharT)) == 0;
+ }
+ }
+};
+} // namespace ah
+
+namespace detail_array_hash {
+
+template <typename T, typename = void>
+struct is_iterator : std::false_type {};
+
+template <typename T>
+struct is_iterator<T, typename std::enable_if<!std::is_same<
+ typename std::iterator_traits<T>::iterator_category,
+ void>::value>::type> : std::true_type {};
+
+static constexpr bool is_power_of_two(std::size_t value) {
+ return value != 0 && (value & (value - 1)) == 0;
+}
+
+template <typename T, typename U>
+static T numeric_cast(U value,
+ const char* error_message = "numeric_cast() failed.") {
+ T ret = static_cast<T>(value);
+ if (static_cast<U>(ret) != value) {
+ throw std::runtime_error(error_message);
+ }
+
+ const bool is_same_signedness =
+ (std::is_unsigned<T>::value && std::is_unsigned<U>::value) ||
+ (std::is_signed<T>::value && std::is_signed<U>::value);
+ if (!is_same_signedness && (ret < T{}) != (value < U{})) {
+ throw std::runtime_error(error_message);
+ }
+
+ return ret;
+}
+
+/**
+ * Fixed size type used to represent size_type values on serialization. Need to
+ * be big enough to represent a std::size_t on 32 and 64 bits platforms, and
+ * must be the same size on both platforms.
+ */
+using slz_size_type = std::uint64_t;
+
+template <class T, class Deserializer>
+static T deserialize_value(Deserializer& deserializer) {
+ // MSVC < 2017 is not conformant, circumvent the problem by removing the
+ // template keyword
+#if defined(_MSC_VER) && _MSC_VER < 1910
+ return deserializer.Deserializer::operator()<T>();
+#else
+ return deserializer.Deserializer::template operator()<T>();
+#endif
+}
+
+/**
+ * For each string in the bucket, store the size of the string, the chars of the
+ * string and T, if it's not void. T should be either void or an unsigned type.
+ *
+ * End the buffer with END_OF_BUCKET flag. END_OF_BUCKET has the same type as
+ * the string size variable.
+ *
+ * m_buffer (CharT*):
+ * | size of str1 (KeySizeT) | str1 (const CharT*) | value (T if T != void) |
+ * ... | | size of strN (KeySizeT) | strN (const CharT*) | value (T if T !=
+ * void) | END_OF_BUCKET (KeySizeT) |
+ *
+ * m_buffer is null if there is no string in the bucket.
+ *
+ * KeySizeT and T are extended to be a multiple of CharT when stored in the
+ * buffer.
+ *
+ * Use std::malloc and std::free instead of new and delete so we can have access
+ * to std::realloc.
+ */
+template <class CharT, class T, class KeyEqual, class KeySizeT,
+ bool StoreNullTerminator>
+class array_bucket {
+ template <typename U>
+ using has_mapped_type =
+ typename std::integral_constant<bool, !std::is_same<U, void>::value>;
+
+ static_assert(!has_mapped_type<T>::value || std::is_unsigned<T>::value,
+ "T should be either void or an unsigned type.");
+
+ static_assert(std::is_unsigned<KeySizeT>::value,
+ "KeySizeT should be an unsigned type.");
+
+ public:
+ template <bool IsConst>
+ class array_bucket_iterator;
+
+ using char_type = CharT;
+ using key_size_type = KeySizeT;
+ using mapped_type = T;
+ using size_type = std::size_t;
+ using key_equal = KeyEqual;
+ using iterator = array_bucket_iterator<false>;
+ using const_iterator = array_bucket_iterator<true>;
+
+ static_assert(sizeof(KeySizeT) <= sizeof(size_type),
+ "sizeof(KeySizeT) should be <= sizeof(std::size_t;)");
+ static_assert(std::is_unsigned<size_type>::value, "");
+
+ private:
+ /**
+ * Return how much space in bytes the type U will take when stored in the
+ * buffer. As the buffer is of type CharT, U may take more space than
+ * sizeof(U).
+ *
+ * Example: sizeof(CharT) = 4, sizeof(U) = 2 => U will take 4 bytes in the
+ * buffer instead of 2.
+ */
+ template <typename U>
+ static constexpr size_type sizeof_in_buff() noexcept {
+ static_assert(is_power_of_two(sizeof(U)),
+ "sizeof(U) should be a power of two.");
+ static_assert(is_power_of_two(sizeof(CharT)),
+ "sizeof(CharT) should be a power of two.");
+
+ return std::max(sizeof(U), sizeof(CharT));
+ }
+
+ /**
+ * Same as sizeof_in_buff<U>, but instead of returning the size in bytes
+ * return it in term of sizeof(CharT).
+ */
+ template <typename U>
+ static constexpr size_type size_as_char_t() noexcept {
+ return sizeof_in_buff<U>() / sizeof(CharT);
+ }
+
+ static key_size_type read_key_size(const CharT* buffer) noexcept {
+ key_size_type key_size;
+ std::memcpy(&key_size, buffer, sizeof(key_size));
+
+ return key_size;
+ }
+
+ static mapped_type read_value(const CharT* buffer) noexcept {
+ mapped_type value;
+ std::memcpy(&value, buffer, sizeof(value));
+
+ return value;
+ }
+
+ static bool is_end_of_bucket(const CharT* buffer) noexcept {
+ return read_key_size(buffer) == END_OF_BUCKET;
+ }
+
+ public:
+ /**
+ * Return the size required for an entry with a key of size 'key_size'.
+ */
+ template <class U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ static size_type entry_required_bytes(size_type key_size) noexcept {
+ return sizeof_in_buff<key_size_type>() +
+ (key_size + KEY_EXTRA_SIZE) * sizeof(CharT);
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ static size_type entry_required_bytes(size_type key_size) noexcept {
+ return sizeof_in_buff<key_size_type>() +
+ (key_size + KEY_EXTRA_SIZE) * sizeof(CharT) +
+ sizeof_in_buff<mapped_type>();
+ }
+
+ private:
+ /**
+ * Return the size of the current entry in buffer.
+ */
+ static size_type entry_size_bytes(const CharT* buffer) noexcept {
+ return entry_required_bytes(read_key_size(buffer));
+ }
+
+ public:
+ template <bool IsConst>
+ class array_bucket_iterator {
+ friend class array_bucket;
+
+ using buffer_type =
+ typename std::conditional<IsConst, const CharT, CharT>::type;
+
+ explicit array_bucket_iterator(buffer_type* position) noexcept
+ : m_position(position) {}
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = void;
+ using difference_type = std::ptrdiff_t;
+ using reference = void;
+ using pointer = void;
+
+ public:
+ array_bucket_iterator() noexcept : m_position(nullptr) {}
+
+ const CharT* key() const {
+ return m_position + size_as_char_t<key_size_type>();
+ }
+
+ size_type key_size() const { return read_key_size(m_position); }
+
+ template <class U = T, typename std::enable_if<
+ has_mapped_type<U>::value>::type* = nullptr>
+ U value() const {
+ return read_value(m_position + size_as_char_t<key_size_type>() +
+ key_size() + KEY_EXTRA_SIZE);
+ }
+
+ template <class U = T, typename std::enable_if<
+ has_mapped_type<U>::value && !IsConst &&
+ std::is_same<U, T>::value>::type* = nullptr>
+ void set_value(U value) noexcept {
+ std::memcpy(m_position + size_as_char_t<key_size_type>() + key_size() +
+ KEY_EXTRA_SIZE,
+ &value, sizeof(value));
+ }
+
+ array_bucket_iterator& operator++() {
+ m_position += entry_size_bytes(m_position) / sizeof(CharT);
+ if (is_end_of_bucket(m_position)) {
+ m_position = nullptr;
+ }
+
+ return *this;
+ }
+
+ array_bucket_iterator operator++(int) {
+ array_bucket_iterator tmp(*this);
+ ++*this;
+
+ return tmp;
+ }
+
+ friend bool operator==(const array_bucket_iterator& lhs,
+ const array_bucket_iterator& rhs) {
+ return lhs.m_position == rhs.m_position;
+ }
+
+ friend bool operator!=(const array_bucket_iterator& lhs,
+ const array_bucket_iterator& rhs) {
+ return !(lhs == rhs);
+ }
+
+ private:
+ buffer_type* m_position;
+ };
+
+ static iterator end_it() noexcept { return iterator(nullptr); }
+
+ static const_iterator cend_it() noexcept { return const_iterator(nullptr); }
+
+ public:
+ array_bucket() : m_buffer(nullptr) {}
+
+ /**
+ * Reserve 'size' in the buffer of the bucket. The created bucket is empty.
+ */
+ array_bucket(std::size_t size) : m_buffer(nullptr) {
+ if (size == 0) {
+ return;
+ }
+
+ m_buffer = static_cast<CharT*>(std::malloc(
+ size * sizeof(CharT) + sizeof_in_buff<decltype(END_OF_BUCKET)>()));
+ if (m_buffer == nullptr) {
+ throw std::bad_alloc();
+ }
+
+ const auto end_of_bucket = END_OF_BUCKET;
+ std::memcpy(m_buffer, &end_of_bucket, sizeof(end_of_bucket));
+ }
+
+ ~array_bucket() { clear(); }
+
+ array_bucket(const array_bucket& other) {
+ if (other.m_buffer == nullptr) {
+ m_buffer = nullptr;
+ return;
+ }
+
+ const size_type other_buffer_size = other.size();
+ m_buffer = static_cast<CharT*>(
+ std::malloc(other_buffer_size * sizeof(CharT) +
+ sizeof_in_buff<decltype(END_OF_BUCKET)>()));
+ if (m_buffer == nullptr) {
+ throw std::bad_alloc();
+ }
+
+ std::memcpy(m_buffer, other.m_buffer, other_buffer_size * sizeof(CharT));
+
+ const auto end_of_bucket = END_OF_BUCKET;
+ std::memcpy(m_buffer + other_buffer_size, &end_of_bucket,
+ sizeof(end_of_bucket));
+ }
+
+ array_bucket(array_bucket&& other) noexcept : m_buffer(other.m_buffer) {
+ other.m_buffer = nullptr;
+ }
+
+ array_bucket& operator=(array_bucket other) noexcept {
+ other.swap(*this);
+
+ return *this;
+ }
+
+ void swap(array_bucket& other) noexcept {
+ std::swap(m_buffer, other.m_buffer);
+ }
+
+ iterator begin() noexcept { return iterator(m_buffer); }
+ iterator end() noexcept { return iterator(nullptr); }
+ const_iterator begin() const noexcept { return cbegin(); }
+ const_iterator end() const noexcept { return cend(); }
+ const_iterator cbegin() const noexcept { return const_iterator(m_buffer); }
+ const_iterator cend() const noexcept { return const_iterator(nullptr); }
+
+ /**
+ * Return an iterator pointing to the key entry if presents or, if not there,
+ * to the position past the last element of the bucket. Return end() if the
+ * bucket has not be initialized yet.
+ *
+ * The boolean of the pair is set to true if the key is there, false
+ * otherwise.
+ */
+ std::pair<const_iterator, bool> find_or_end_of_bucket(
+ const CharT* key, size_type key_size) const noexcept {
+ if (m_buffer == nullptr) {
+ return std::make_pair(cend(), false);
+ }
+
+ const CharT* buffer_ptr_in_out = m_buffer;
+ const bool found =
+ find_or_end_of_bucket_impl(key, key_size, buffer_ptr_in_out);
+
+ return std::make_pair(const_iterator(buffer_ptr_in_out), found);
+ }
+
+ /**
+ * Append the element 'key' with its potential value at the end of the bucket.
+ * 'end_of_bucket' should point past the end of the last element in the
+ * bucket, end() if the bucket was not initialized yet. You usually get this
+ * value from find_or_end_of_bucket.
+ *
+ * Return the position where the element was actually inserted.
+ */
+ template <class... ValueArgs>
+ const_iterator append(const_iterator end_of_bucket, const CharT* key,
+ size_type key_size, ValueArgs&&... value) {
+ const key_size_type key_sz = as_key_size_type(key_size);
+
+ if (end_of_bucket == cend()) {
+ tsl_ah_assert(m_buffer == nullptr);
+
+ const size_type buffer_size = entry_required_bytes(key_sz) +
+ sizeof_in_buff<decltype(END_OF_BUCKET)>();
+
+ m_buffer = static_cast<CharT*>(std::malloc(buffer_size));
+ if (m_buffer == nullptr) {
+ throw std::bad_alloc();
+ }
+
+ append_impl(key, key_sz, m_buffer, std::forward<ValueArgs>(value)...);
+
+ return const_iterator(m_buffer);
+ } else {
+ tsl_ah_assert(is_end_of_bucket(end_of_bucket.m_position));
+
+ const size_type current_size =
+ ((end_of_bucket.m_position +
+ size_as_char_t<decltype(END_OF_BUCKET)>()) -
+ m_buffer) *
+ sizeof(CharT);
+ const size_type new_size = current_size + entry_required_bytes(key_sz);
+
+ CharT* new_buffer = static_cast<CharT*>(std::realloc(m_buffer, new_size));
+ if (new_buffer == nullptr) {
+ throw std::bad_alloc();
+ }
+ m_buffer = new_buffer;
+
+ CharT* buffer_append_pos = m_buffer + current_size / sizeof(CharT) -
+ size_as_char_t<decltype(END_OF_BUCKET)>();
+ append_impl(key, key_sz, buffer_append_pos,
+ std::forward<ValueArgs>(value)...);
+
+ return const_iterator(buffer_append_pos);
+ }
+ }
+
+ const_iterator erase(const_iterator position) noexcept {
+ tsl_ah_assert(position.m_position != nullptr &&
+ !is_end_of_bucket(position.m_position));
+
+ // get mutable pointers
+ CharT* start_entry = m_buffer + (position.m_position - m_buffer);
+ CharT* start_next_entry =
+ start_entry + entry_size_bytes(start_entry) / sizeof(CharT);
+
+ CharT* end_buffer_ptr = start_next_entry;
+ while (!is_end_of_bucket(end_buffer_ptr)) {
+ end_buffer_ptr += entry_size_bytes(end_buffer_ptr) / sizeof(CharT);
+ }
+ end_buffer_ptr += size_as_char_t<decltype(END_OF_BUCKET)>();
+
+ const size_type size_to_move =
+ (end_buffer_ptr - start_next_entry) * sizeof(CharT);
+ std::memmove(start_entry, start_next_entry, size_to_move);
+
+ if (is_end_of_bucket(m_buffer)) {
+ clear();
+ return cend();
+ } else if (is_end_of_bucket(start_entry)) {
+ return cend();
+ } else {
+ return const_iterator(start_entry);
+ }
+ }
+
+ /**
+ * Return true if an element has been erased
+ */
+ bool erase(const CharT* key, size_type key_size) noexcept {
+ if (m_buffer == nullptr) {
+ return false;
+ }
+
+ const CharT* entry_buffer_ptr_in_out = m_buffer;
+ bool found =
+ find_or_end_of_bucket_impl(key, key_size, entry_buffer_ptr_in_out);
+ if (found) {
+ erase(const_iterator(entry_buffer_ptr_in_out));
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Bucket should be big enough and there is no check to see if the key already
+ * exists. No check on key_size.
+ */
+ template <class... ValueArgs>
+ void append_in_reserved_bucket_no_check(const CharT* key, size_type key_size,
+ ValueArgs&&... value) noexcept {
+ CharT* buffer_ptr = m_buffer;
+ while (!is_end_of_bucket(buffer_ptr)) {
+ buffer_ptr += entry_size_bytes(buffer_ptr) / sizeof(CharT);
+ }
+
+ append_impl(key, key_size_type(key_size), buffer_ptr,
+ std::forward<ValueArgs>(value)...);
+ }
+
+ bool empty() const noexcept {
+ return m_buffer == nullptr || is_end_of_bucket(m_buffer);
+ }
+
+ void clear() noexcept {
+ std::free(m_buffer);
+ m_buffer = nullptr;
+ }
+
+ iterator mutable_iterator(const_iterator pos) noexcept {
+ return iterator(m_buffer + (pos.m_position - m_buffer));
+ }
+
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ const slz_size_type bucket_size = size();
+ tsl_ah_assert(m_buffer != nullptr || bucket_size == 0);
+
+ serializer(bucket_size);
+ serializer(m_buffer, bucket_size);
+ }
+
+ template <class Deserializer>
+ static array_bucket deserialize(Deserializer& deserializer) {
+ array_bucket bucket;
+ const slz_size_type bucket_size_ds =
+ deserialize_value<slz_size_type>(deserializer);
+
+ if (bucket_size_ds == 0) {
+ return bucket;
+ }
+
+ const std::size_t bucket_size = numeric_cast<std::size_t>(
+ bucket_size_ds, "Deserialized bucket_size is too big.");
+ bucket.m_buffer = static_cast<CharT*>(
+ std::malloc(bucket_size * sizeof(CharT) +
+ sizeof_in_buff<decltype(END_OF_BUCKET)>()));
+ if (bucket.m_buffer == nullptr) {
+ throw std::bad_alloc();
+ }
+
+ deserializer(bucket.m_buffer, bucket_size);
+
+ const auto end_of_bucket = END_OF_BUCKET;
+ std::memcpy(bucket.m_buffer + bucket_size, &end_of_bucket,
+ sizeof(end_of_bucket));
+
+ tsl_ah_assert(bucket.size() == bucket_size);
+ return bucket;
+ }
+
+ private:
+ key_size_type as_key_size_type(size_type key_size) const {
+ if (key_size > MAX_KEY_SIZE) {
+ throw std::length_error("Key is too long.");
+ }
+
+ return key_size_type(key_size);
+ }
+
+ /*
+ * Return true if found, false otherwise.
+ * If true, buffer_ptr_in_out points to the start of the entry matching 'key'.
+ * If false, buffer_ptr_in_out points to where the 'key' should be inserted.
+ *
+ * Start search from buffer_ptr_in_out.
+ */
+ bool find_or_end_of_bucket_impl(const CharT* key, size_type key_size,
+ const CharT*& buffer_ptr_in_out) const
+ noexcept {
+ while (!is_end_of_bucket(buffer_ptr_in_out)) {
+ const key_size_type buffer_key_size = read_key_size(buffer_ptr_in_out);
+ const CharT* buffer_str =
+ buffer_ptr_in_out + size_as_char_t<key_size_type>();
+ if (KeyEqual()(buffer_str, buffer_key_size, key, key_size)) {
+ return true;
+ }
+
+ buffer_ptr_in_out += entry_size_bytes(buffer_ptr_in_out) / sizeof(CharT);
+ }
+
+ return false;
+ }
+
+ template <typename U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ void append_impl(const CharT* key, key_size_type key_size,
+ CharT* buffer_append_pos) noexcept {
+ std::memcpy(buffer_append_pos, &key_size, sizeof(key_size));
+ buffer_append_pos += size_as_char_t<key_size_type>();
+
+ std::memcpy(buffer_append_pos, key, key_size * sizeof(CharT));
+ buffer_append_pos += key_size;
+
+ const CharT zero = 0;
+ std::memcpy(buffer_append_pos, &zero, KEY_EXTRA_SIZE * sizeof(CharT));
+ buffer_append_pos += KEY_EXTRA_SIZE;
+
+ const auto end_of_bucket = END_OF_BUCKET;
+ std::memcpy(buffer_append_pos, &end_of_bucket, sizeof(end_of_bucket));
+ }
+
+ template <typename U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ void append_impl(
+ const CharT* key, key_size_type key_size, CharT* buffer_append_pos,
+ typename array_bucket<CharT, U, KeyEqual, KeySizeT,
+ StoreNullTerminator>::mapped_type value) noexcept {
+ std::memcpy(buffer_append_pos, &key_size, sizeof(key_size));
+ buffer_append_pos += size_as_char_t<key_size_type>();
+
+ std::memcpy(buffer_append_pos, key, key_size * sizeof(CharT));
+ buffer_append_pos += key_size;
+
+ const CharT zero = 0;
+ std::memcpy(buffer_append_pos, &zero, KEY_EXTRA_SIZE * sizeof(CharT));
+ buffer_append_pos += KEY_EXTRA_SIZE;
+
+ std::memcpy(buffer_append_pos, &value, sizeof(value));
+ buffer_append_pos += size_as_char_t<mapped_type>();
+
+ const auto end_of_bucket = END_OF_BUCKET;
+ std::memcpy(buffer_append_pos, &end_of_bucket, sizeof(end_of_bucket));
+ }
+
+ /**
+ * Return the number of CharT in m_buffer. As the size of the buffer is not
+ * stored to gain some space, the method need to find the EOF marker and is
+ * thus in O(n).
+ */
+ size_type size() const noexcept {
+ if (m_buffer == nullptr) {
+ return 0;
+ }
+
+ CharT* buffer_ptr = m_buffer;
+ while (!is_end_of_bucket(buffer_ptr)) {
+ buffer_ptr += entry_size_bytes(buffer_ptr) / sizeof(CharT);
+ }
+
+ return buffer_ptr - m_buffer;
+ }
+
+ private:
+ static const key_size_type END_OF_BUCKET =
+ std::numeric_limits<key_size_type>::max();
+ static const key_size_type KEY_EXTRA_SIZE = StoreNullTerminator ? 1 : 0;
+
+ CharT* m_buffer;
+
+ public:
+ static const key_size_type MAX_KEY_SIZE =
+ // -1 for END_OF_BUCKET
+ key_size_type(std::numeric_limits<key_size_type>::max() - KEY_EXTRA_SIZE -
+ 1);
+};
+
+template <class T>
+class value_container {
+ public:
+ void clear() noexcept { m_values.clear(); }
+
+ void reserve(std::size_t new_cap) { m_values.reserve(new_cap); }
+
+ void shrink_to_fit() { m_values.shrink_to_fit(); }
+
+ friend void swap(value_container& lhs, value_container& rhs) {
+ lhs.m_values.swap(rhs.m_values);
+ }
+
+ protected:
+ static constexpr float VECTOR_GROWTH_RATE = 1.5f;
+
+ // TODO use a sparse array? or a std::deque
+ std::vector<T> m_values;
+};
+
+template <>
+class value_container<void> {
+ public:
+ void clear() noexcept {}
+
+ void shrink_to_fit() {}
+
+ void reserve(std::size_t /*new_cap*/) {}
+};
+
+/**
+ * If there is no value in the array_hash (in the case of a set for example), T
+ * should be void.
+ *
+ * The size of a key string is limited to std::numeric_limits<KeySizeT>::max()
+ * - 1.
+ *
+ * The number of elements in the map is limited to
+ * std::numeric_limits<IndexSizeT>::max().
+ */
+template <class CharT, class T, class Hash, class KeyEqual,
+ bool StoreNullTerminator, class KeySizeT, class IndexSizeT,
+ class GrowthPolicy>
+class array_hash : private value_container<T>,
+ private Hash,
+ private GrowthPolicy {
+ private:
+ template <typename U>
+ using has_mapped_type =
+ typename std::integral_constant<bool, !std::is_same<U, void>::value>;
+
+ /**
+ * If there is a mapped type in array_hash, we store the values in m_values of
+ * value_container class and we store an index to m_values in the bucket. The
+ * index is of type IndexSizeT.
+ */
+ using array_bucket = tsl::detail_array_hash::array_bucket<
+ CharT,
+ typename std::conditional<has_mapped_type<T>::value, IndexSizeT,
+ void>::type,
+ KeyEqual, KeySizeT, StoreNullTerminator>;
+
+ public:
+ template <bool IsConst>
+ class array_hash_iterator;
+
+ using char_type = CharT;
+ using key_size_type = KeySizeT;
+ using index_size_type = IndexSizeT;
+ using size_type = std::size_t;
+ using hasher = Hash;
+ using key_equal = KeyEqual;
+ using iterator = array_hash_iterator<false>;
+ using const_iterator = array_hash_iterator<true>;
+
+ /*
+ * Iterator classes
+ */
+ public:
+ template <bool IsConst>
+ class array_hash_iterator {
+ friend class array_hash;
+
+ private:
+ using iterator_array_bucket = typename array_bucket::const_iterator;
+
+ using iterator_buckets = typename std::conditional<
+ IsConst, typename std::vector<array_bucket>::const_iterator,
+ typename std::vector<array_bucket>::iterator>::type;
+
+ using array_hash_ptr = typename std::conditional<IsConst, const array_hash*,
+ array_hash*>::type;
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type =
+ typename std::conditional<has_mapped_type<T>::value, T, void>::type;
+ using difference_type = std::ptrdiff_t;
+ using reference = typename std::conditional<
+ has_mapped_type<T>::value,
+ typename std::conditional<
+ IsConst, typename std::add_lvalue_reference<const T>::type,
+ typename std::add_lvalue_reference<T>::type>::type,
+ void>::type;
+ using pointer = typename std::conditional<
+ has_mapped_type<T>::value,
+ typename std::conditional<IsConst, const T*, T*>::type, void>::type;
+
+ private:
+ array_hash_iterator(iterator_buckets buckets_iterator,
+ iterator_array_bucket array_bucket_iterator,
+ array_hash_ptr array_hash_p) noexcept
+ : m_buckets_iterator(buckets_iterator),
+ m_array_bucket_iterator(array_bucket_iterator),
+ m_array_hash(array_hash_p) {
+ tsl_ah_assert(m_array_hash != nullptr);
+ }
+
+ public:
+ array_hash_iterator() noexcept : m_array_hash(nullptr) {}
+
+ template <bool TIsConst = IsConst,
+ typename std::enable_if<TIsConst>::type* = nullptr>
+ array_hash_iterator(const array_hash_iterator<!TIsConst>& other) noexcept
+ : m_buckets_iterator(other.m_buckets_iterator),
+ m_array_bucket_iterator(other.m_array_bucket_iterator),
+ m_array_hash(other.m_array_hash) {}
+
+ array_hash_iterator(const array_hash_iterator& other) = default;
+ array_hash_iterator(array_hash_iterator&& other) = default;
+ array_hash_iterator& operator=(const array_hash_iterator& other) = default;
+ array_hash_iterator& operator=(array_hash_iterator&& other) = default;
+
+ const CharT* key() const { return m_array_bucket_iterator.key(); }
+
+ size_type key_size() const { return m_array_bucket_iterator.key_size(); }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::basic_string_view<CharT> key_sv() const {
+ return std::basic_string_view<CharT>(key(), key_size());
+ }
+#endif
+
+ template <class U = T, typename std::enable_if<
+ has_mapped_type<U>::value>::type* = nullptr>
+ reference value() const {
+ return this->m_array_hash->m_values[value_position()];
+ }
+
+ template <class U = T, typename std::enable_if<
+ has_mapped_type<U>::value>::type* = nullptr>
+ reference operator*() const {
+ return value();
+ }
+
+ template <class U = T, typename std::enable_if<
+ has_mapped_type<U>::value>::type* = nullptr>
+ pointer operator->() const {
+ return std::addressof(value());
+ }
+
+ array_hash_iterator& operator++() {
+ tsl_ah_assert(m_buckets_iterator != m_array_hash->m_buckets_data.end());
+ tsl_ah_assert(m_array_bucket_iterator != m_buckets_iterator->cend());
+
+ ++m_array_bucket_iterator;
+ if (m_array_bucket_iterator == m_buckets_iterator->cend()) {
+ do {
+ ++m_buckets_iterator;
+ } while (m_buckets_iterator != m_array_hash->m_buckets_data.end() &&
+ m_buckets_iterator->empty());
+
+ if (m_buckets_iterator != m_array_hash->m_buckets_data.end()) {
+ m_array_bucket_iterator = m_buckets_iterator->cbegin();
+ }
+ }
+
+ return *this;
+ }
+
+ array_hash_iterator operator++(int) {
+ array_hash_iterator tmp(*this);
+ ++*this;
+
+ return tmp;
+ }
+
+ friend bool operator==(const array_hash_iterator& lhs,
+ const array_hash_iterator& rhs) {
+ return lhs.m_buckets_iterator == rhs.m_buckets_iterator &&
+ lhs.m_array_bucket_iterator == rhs.m_array_bucket_iterator &&
+ lhs.m_array_hash == rhs.m_array_hash;
+ }
+
+ friend bool operator!=(const array_hash_iterator& lhs,
+ const array_hash_iterator& rhs) {
+ return !(lhs == rhs);
+ }
+
+ private:
+ template <class U = T, typename std::enable_if<
+ has_mapped_type<U>::value>::type* = nullptr>
+ IndexSizeT value_position() const {
+ return this->m_array_bucket_iterator.value();
+ }
+
+ private:
+ iterator_buckets m_buckets_iterator;
+ iterator_array_bucket m_array_bucket_iterator;
+
+ array_hash_ptr m_array_hash;
+ };
+
+ public:
+ array_hash(size_type bucket_count, const Hash& hash, float max_load_factor)
+ : value_container<T>(),
+ Hash(hash),
+ GrowthPolicy(bucket_count),
+ m_buckets_data(bucket_count > max_bucket_count()
+ ? throw std::length_error(
+ "The map exceeds its maximum bucket count.")
+ : bucket_count),
+ m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
+ : m_buckets_data.data()),
+ m_nb_elements(0) {
+ this->max_load_factor(max_load_factor);
+ }
+
+ array_hash(const array_hash& other)
+ : value_container<T>(other),
+ Hash(other),
+ GrowthPolicy(other),
+ m_buckets_data(other.m_buckets_data),
+ m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
+ : m_buckets_data.data()),
+ m_nb_elements(other.m_nb_elements),
+ m_max_load_factor(other.m_max_load_factor),
+ m_load_threshold(other.m_load_threshold) {}
+
+ array_hash(array_hash&& other) noexcept(
+ std::is_nothrow_move_constructible<value_container<T>>::value&&
+ std::is_nothrow_move_constructible<Hash>::value&&
+ std::is_nothrow_move_constructible<GrowthPolicy>::value&&
+ std::is_nothrow_move_constructible<
+ std::vector<array_bucket>>::value)
+ : value_container<T>(std::move(other)),
+ Hash(std::move(other)),
+ GrowthPolicy(std::move(other)),
+ m_buckets_data(std::move(other.m_buckets_data)),
+ m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
+ : m_buckets_data.data()),
+ m_nb_elements(other.m_nb_elements),
+ m_max_load_factor(other.m_max_load_factor),
+ m_load_threshold(other.m_load_threshold) {
+ other.value_container<T>::clear();
+ other.GrowthPolicy::clear();
+ other.m_buckets_data.clear();
+ other.m_buckets = static_empty_bucket_ptr();
+ other.m_nb_elements = 0;
+ other.m_load_threshold = 0;
+ }
+
+ array_hash& operator=(const array_hash& other) {
+ if (&other != this) {
+ value_container<T>::operator=(other);
+ Hash::operator=(other);
+ GrowthPolicy::operator=(other);
+
+ m_buckets_data = other.m_buckets_data;
+ m_buckets = m_buckets_data.empty() ? static_empty_bucket_ptr()
+ : m_buckets_data.data();
+ m_nb_elements = other.m_nb_elements;
+ m_max_load_factor = other.m_max_load_factor;
+ m_load_threshold = other.m_load_threshold;
+ }
+
+ return *this;
+ }
+
+ array_hash& operator=(array_hash&& other) {
+ other.swap(*this);
+ other.clear();
+
+ return *this;
+ }
+
+ /*
+ * Iterators
+ */
+ iterator begin() noexcept {
+ auto begin = m_buckets_data.begin();
+ while (begin != m_buckets_data.end() && begin->empty()) {
+ ++begin;
+ }
+
+ return (begin != m_buckets_data.end())
+ ? iterator(begin, begin->cbegin(), this)
+ : end();
+ }
+
+ const_iterator begin() const noexcept { return cbegin(); }
+
+ const_iterator cbegin() const noexcept {
+ auto begin = m_buckets_data.cbegin();
+ while (begin != m_buckets_data.cend() && begin->empty()) {
+ ++begin;
+ }
+
+ return (begin != m_buckets_data.cend())
+ ? const_iterator(begin, begin->cbegin(), this)
+ : cend();
+ }
+
+ iterator end() noexcept {
+ return iterator(m_buckets_data.end(), array_bucket::cend_it(), this);
+ }
+
+ const_iterator end() const noexcept { return cend(); }
+
+ const_iterator cend() const noexcept {
+ return const_iterator(m_buckets_data.end(), array_bucket::cend_it(), this);
+ }
+
+ /*
+ * Capacity
+ */
+ bool empty() const noexcept { return m_nb_elements == 0; }
+
+ size_type size() const noexcept { return m_nb_elements; }
+
+ size_type max_size() const noexcept {
+ return std::numeric_limits<IndexSizeT>::max();
+ }
+
+ size_type max_key_size() const noexcept { return MAX_KEY_SIZE; }
+
+ void shrink_to_fit() {
+ clear_old_erased_values();
+ value_container<T>::shrink_to_fit();
+
+ rehash_impl(size_type(std::ceil(float(size()) / max_load_factor())));
+ }
+
+ /*
+ * Modifiers
+ */
+ void clear() noexcept {
+ value_container<T>::clear();
+
+ for (auto& bucket : m_buckets_data) {
+ bucket.clear();
+ }
+
+ m_nb_elements = 0;
+ }
+
+ template <class... ValueArgs>
+ std::pair<iterator, bool> emplace(const CharT* key, size_type key_size,
+ ValueArgs&&... value_args) {
+ const std::size_t hash = hash_key(key, key_size);
+ std::size_t ibucket = bucket_for_hash(hash);
+
+ auto it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ if (it_find.second) {
+ return std::make_pair(
+ iterator(m_buckets_data.begin() + ibucket, it_find.first, this),
+ false);
+ }
+
+ if (grow_on_high_load()) {
+ ibucket = bucket_for_hash(hash);
+ it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ }
+
+ return emplace_impl(ibucket, it_find.first, key, key_size,
+ std::forward<ValueArgs>(value_args)...);
+ }
+
+ template <class M>
+ std::pair<iterator, bool> insert_or_assign(const CharT* key,
+ size_type key_size, M&& obj) {
+ auto it = emplace(key, key_size, std::forward<M>(obj));
+ if (!it.second) {
+ it.first.value() = std::forward<M>(obj);
+ }
+
+ return it;
+ }
+
+ iterator erase(const_iterator pos) {
+ if (should_clear_old_erased_values()) {
+ clear_old_erased_values();
+ }
+
+ return erase_from_bucket(mutable_iterator(pos));
+ }
+
+ iterator erase(const_iterator first, const_iterator last) {
+ if (first == last) {
+ return mutable_iterator(first);
+ }
+
+ /**
+ * When erasing an element from a bucket with erase_from_bucket, it
+ * invalidates all the iterators in the array bucket of the element
+ * (m_array_bucket_iterator) but not the iterators of the buckets itself
+ * (m_buckets_iterator).
+ *
+ * So first erase all the values between first and last which are not part
+ * of the bucket of last, and then erase carefully the values in last's
+ * bucket.
+ */
+ auto to_delete = mutable_iterator(first);
+ while (to_delete.m_buckets_iterator != last.m_buckets_iterator) {
+ to_delete = erase_from_bucket(to_delete);
+ }
+
+ std::size_t nb_elements_until_last = std::distance(
+ to_delete.m_array_bucket_iterator, last.m_array_bucket_iterator);
+ while (nb_elements_until_last > 0) {
+ to_delete = erase_from_bucket(to_delete);
+ nb_elements_until_last--;
+ }
+
+ if (should_clear_old_erased_values()) {
+ clear_old_erased_values();
+ }
+
+ return to_delete;
+ }
+
+ size_type erase(const CharT* key, size_type key_size) {
+ return erase(key, key_size, hash_key(key, key_size));
+ }
+
+ size_type erase(const CharT* key, size_type key_size, std::size_t hash) {
+ if (should_clear_old_erased_values()) {
+ clear_old_erased_values();
+ }
+
+ const std::size_t ibucket = bucket_for_hash(hash);
+ if (m_buckets[ibucket].erase(key, key_size)) {
+ m_nb_elements--;
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ void swap(array_hash& other) {
+ using std::swap;
+
+ swap(static_cast<value_container<T>&>(*this),
+ static_cast<value_container<T>&>(other));
+ swap(static_cast<Hash&>(*this), static_cast<Hash&>(other));
+ swap(static_cast<GrowthPolicy&>(*this), static_cast<GrowthPolicy&>(other));
+ swap(m_buckets_data, other.m_buckets_data);
+ swap(m_buckets, other.m_buckets);
+ swap(m_nb_elements, other.m_nb_elements);
+ swap(m_max_load_factor, other.m_max_load_factor);
+ swap(m_load_threshold, other.m_load_threshold);
+ }
+
+ /*
+ * Lookup
+ */
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ U& at(const CharT* key, size_type key_size) {
+ return at(key, key_size, hash_key(key, key_size));
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ const U& at(const CharT* key, size_type key_size) const {
+ return at(key, key_size, hash_key(key, key_size));
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ U& at(const CharT* key, size_type key_size, std::size_t hash) {
+ return const_cast<U&>(
+ static_cast<const array_hash*>(this)->at(key, key_size, hash));
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ const U& at(const CharT* key, size_type key_size, std::size_t hash) const {
+ const std::size_t ibucket = bucket_for_hash(hash);
+
+ auto it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ if (it_find.second) {
+ return this->m_values[it_find.first.value()];
+ } else {
+ throw std::out_of_range("Couldn't find key.");
+ }
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ U& access_operator(const CharT* key, size_type key_size) {
+ const std::size_t hash = hash_key(key, key_size);
+ std::size_t ibucket = bucket_for_hash(hash);
+
+ auto it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ if (it_find.second) {
+ return this->m_values[it_find.first.value()];
+ } else {
+ if (grow_on_high_load()) {
+ ibucket = bucket_for_hash(hash);
+ it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ }
+
+ return emplace_impl(ibucket, it_find.first, key, key_size, U{})
+ .first.value();
+ }
+ }
+
+ size_type count(const CharT* key, size_type key_size) const {
+ return count(key, key_size, hash_key(key, key_size));
+ }
+
+ size_type count(const CharT* key, size_type key_size,
+ std::size_t hash) const {
+ const std::size_t ibucket = bucket_for_hash(hash);
+
+ auto it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ if (it_find.second) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ iterator find(const CharT* key, size_type key_size) {
+ return find(key, key_size, hash_key(key, key_size));
+ }
+
+ const_iterator find(const CharT* key, size_type key_size) const {
+ return find(key, key_size, hash_key(key, key_size));
+ }
+
+ iterator find(const CharT* key, size_type key_size, std::size_t hash) {
+ const std::size_t ibucket = bucket_for_hash(hash);
+
+ auto it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ if (it_find.second) {
+ return iterator(m_buckets_data.begin() + ibucket, it_find.first, this);
+ } else {
+ return end();
+ }
+ }
+
+ const_iterator find(const CharT* key, size_type key_size,
+ std::size_t hash) const {
+ const std::size_t ibucket = bucket_for_hash(hash);
+
+ auto it_find = m_buckets[ibucket].find_or_end_of_bucket(key, key_size);
+ if (it_find.second) {
+ return const_iterator(m_buckets_data.cbegin() + ibucket, it_find.first,
+ this);
+ } else {
+ return cend();
+ }
+ }
+
+ std::pair<iterator, iterator> equal_range(const CharT* key,
+ size_type key_size) {
+ return equal_range(key, key_size, hash_key(key, key_size));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key, size_type key_size) const {
+ return equal_range(key, key_size, hash_key(key, key_size));
+ }
+
+ std::pair<iterator, iterator> equal_range(const CharT* key,
+ size_type key_size,
+ std::size_t hash) {
+ iterator it = find(key, key_size, hash);
+ return std::make_pair(it, (it == end()) ? it : std::next(it));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key, size_type key_size, std::size_t hash) const {
+ const_iterator it = find(key, key_size, hash);
+ return std::make_pair(it, (it == cend()) ? it : std::next(it));
+ }
+
+ /*
+ * Bucket interface
+ */
+ size_type bucket_count() const { return m_buckets_data.size(); }
+
+ size_type max_bucket_count() const {
+ return std::min(GrowthPolicy::max_bucket_count(),
+ m_buckets_data.max_size());
+ }
+
+ /*
+ * Hash policy
+ */
+ float load_factor() const {
+ if (bucket_count() == 0) {
+ return 0;
+ }
+
+ return float(m_nb_elements) / float(bucket_count());
+ }
+
+ float max_load_factor() const { return m_max_load_factor; }
+
+ void max_load_factor(float ml) {
+ m_max_load_factor = std::max(0.1f, ml);
+ m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
+ }
+
+ void rehash(size_type count) {
+ count = std::max(count,
+ size_type(std::ceil(float(size()) / max_load_factor())));
+ rehash_impl(count);
+ }
+
+ void reserve(size_type count) {
+ rehash(size_type(std::ceil(float(count) / max_load_factor())));
+ }
+
+ /*
+ * Observers
+ */
+ hasher hash_function() const { return static_cast<const hasher&>(*this); }
+
+ // TODO add support for statefull KeyEqual
+ key_equal key_eq() const { return KeyEqual(); }
+
+ /*
+ * Other
+ */
+ iterator mutable_iterator(const_iterator it) noexcept {
+ auto it_bucket =
+ m_buckets_data.begin() +
+ std::distance(m_buckets_data.cbegin(), it.m_buckets_iterator);
+ return iterator(it_bucket, it.m_array_bucket_iterator, this);
+ }
+
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ serialize_impl(serializer);
+ }
+
+ template <class Deserializer>
+ void deserialize(Deserializer& deserializer, bool hash_compatible) {
+ deserialize_impl(deserializer, hash_compatible);
+ }
+
+ private:
+ std::size_t hash_key(const CharT* key, size_type key_size) const {
+ return Hash::operator()(key, key_size);
+ }
+
+ std::size_t bucket_for_hash(std::size_t hash) const {
+ return GrowthPolicy::bucket_for_hash(hash);
+ }
+
+ /**
+ * If there is a mapped_type, the mapped value in m_values is not erased now.
+ * It will be erased when the ratio between the size of the map and
+ * the size of the map + the number of deleted values still stored is low
+ * enough (see clear_old_erased_values).
+ */
+ iterator erase_from_bucket(iterator pos) noexcept {
+ auto array_bucket_next_it =
+ pos.m_buckets_iterator->erase(pos.m_array_bucket_iterator);
+ m_nb_elements--;
+
+ if (array_bucket_next_it != pos.m_buckets_iterator->cend()) {
+ return iterator(pos.m_buckets_iterator, array_bucket_next_it, this);
+ } else {
+ do {
+ ++pos.m_buckets_iterator;
+ } while (pos.m_buckets_iterator != m_buckets_data.end() &&
+ pos.m_buckets_iterator->empty());
+
+ if (pos.m_buckets_iterator != m_buckets_data.end()) {
+ return iterator(pos.m_buckets_iterator,
+ pos.m_buckets_iterator->cbegin(), this);
+ } else {
+ return end();
+ }
+ }
+ }
+
+ template <class U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ bool should_clear_old_erased_values(
+ float /*threshold*/ = DEFAULT_CLEAR_OLD_ERASED_VALUE_THRESHOLD) const {
+ return false;
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ bool should_clear_old_erased_values(
+ float threshold = DEFAULT_CLEAR_OLD_ERASED_VALUE_THRESHOLD) const {
+ if (this->m_values.size() == 0) {
+ return false;
+ }
+
+ return float(m_nb_elements) / float(this->m_values.size()) < threshold;
+ }
+
+ template <class U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ void clear_old_erased_values() {}
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ void clear_old_erased_values() {
+ static_assert(std::is_nothrow_move_constructible<U>::value ||
+ std::is_copy_constructible<U>::value,
+ "mapped_value must be either copy constructible or nothrow "
+ "move constructible.");
+
+ if (m_nb_elements == this->m_values.size()) {
+ return;
+ }
+
+ std::vector<T> new_values;
+ new_values.reserve(size());
+
+ for (auto it = begin(); it != end(); ++it) {
+ new_values.push_back(std::move_if_noexcept(it.value()));
+ }
+
+ IndexSizeT ivalue = 0;
+ for (auto it = begin(); it != end(); ++it) {
+ auto it_array_bucket =
+ it.m_buckets_iterator->mutable_iterator(it.m_array_bucket_iterator);
+ it_array_bucket.set_value(ivalue);
+ ivalue++;
+ }
+
+ new_values.swap(this->m_values);
+ tsl_ah_assert(m_nb_elements == this->m_values.size());
+ }
+
+ /**
+ * Return true if a rehash occurred.
+ */
+ bool grow_on_high_load() {
+ if (size() >= m_load_threshold) {
+ rehash_impl(GrowthPolicy::next_bucket_count());
+ return true;
+ }
+
+ return false;
+ }
+
+ template <class... ValueArgs, class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ std::pair<iterator, bool> emplace_impl(
+ std::size_t ibucket, typename array_bucket::const_iterator end_of_bucket,
+ const CharT* key, size_type key_size, ValueArgs&&... value_args) {
+ if (this->m_values.size() >= max_size()) {
+ // Try to clear old erased values lingering in m_values. Throw if it
+ // doesn't change anything.
+ clear_old_erased_values();
+ if (this->m_values.size() >= max_size()) {
+ throw std::length_error(
+ "Can't insert value, too much values in the map.");
+ }
+ }
+
+ if (this->m_values.size() == this->m_values.capacity()) {
+ this->m_values.reserve(
+ std::size_t(float(this->m_values.size()) *
+ value_container<T>::VECTOR_GROWTH_RATE));
+ }
+
+ this->m_values.emplace_back(std::forward<ValueArgs>(value_args)...);
+
+ try {
+ auto it = m_buckets[ibucket].append(
+ end_of_bucket, key, key_size, IndexSizeT(this->m_values.size() - 1));
+ m_nb_elements++;
+
+ return std::make_pair(
+ iterator(m_buckets_data.begin() + ibucket, it, this), true);
+ } catch (...) {
+ // Rollback
+ this->m_values.pop_back();
+ throw;
+ }
+ }
+
+ template <class U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ std::pair<iterator, bool> emplace_impl(
+ std::size_t ibucket, typename array_bucket::const_iterator end_of_bucket,
+ const CharT* key, size_type key_size) {
+ if (m_nb_elements >= max_size()) {
+ throw std::length_error(
+ "Can't insert value, too much values in the map.");
+ }
+
+ auto it = m_buckets[ibucket].append(end_of_bucket, key, key_size);
+ m_nb_elements++;
+
+ return std::make_pair(iterator(m_buckets_data.begin() + ibucket, it, this),
+ true);
+ }
+
+ void rehash_impl(size_type bucket_count) {
+ GrowthPolicy new_growth_policy(bucket_count);
+ if (bucket_count == this->bucket_count()) {
+ return;
+ }
+
+ if (should_clear_old_erased_values(
+ REHASH_CLEAR_OLD_ERASED_VALUE_THRESHOLD)) {
+ clear_old_erased_values();
+ }
+
+ std::vector<std::size_t> required_size_for_bucket(bucket_count, 0);
+ std::vector<std::size_t> bucket_for_ivalue(size(), 0);
+
+ std::size_t ivalue = 0;
+ for (auto it = begin(); it != end(); ++it) {
+ const std::size_t hash = hash_key(it.key(), it.key_size());
+ const std::size_t ibucket = new_growth_policy.bucket_for_hash(hash);
+
+ bucket_for_ivalue[ivalue] = ibucket;
+ required_size_for_bucket[ibucket] +=
+ array_bucket::entry_required_bytes(it.key_size());
+ ivalue++;
+ }
+
+ std::vector<array_bucket> new_buckets;
+ new_buckets.reserve(bucket_count);
+ for (std::size_t ibucket = 0; ibucket < bucket_count; ibucket++) {
+ new_buckets.emplace_back(required_size_for_bucket[ibucket]);
+ }
+
+ ivalue = 0;
+ for (auto it = begin(); it != end(); ++it) {
+ const std::size_t ibucket = bucket_for_ivalue[ivalue];
+ append_iterator_in_reserved_bucket_no_check(new_buckets[ibucket], it);
+
+ ivalue++;
+ }
+
+ using std::swap;
+ swap(static_cast<GrowthPolicy&>(*this), new_growth_policy);
+
+ m_buckets_data.swap(new_buckets);
+ m_buckets = !m_buckets_data.empty() ? m_buckets_data.data()
+ : static_empty_bucket_ptr();
+
+ // Call max_load_factor to change m_load_threshold
+ max_load_factor(m_max_load_factor);
+ }
+
+ template <class U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ void append_iterator_in_reserved_bucket_no_check(array_bucket& bucket,
+ iterator it) {
+ bucket.append_in_reserved_bucket_no_check(it.key(), it.key_size());
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ void append_iterator_in_reserved_bucket_no_check(array_bucket& bucket,
+ iterator it) {
+ bucket.append_in_reserved_bucket_no_check(it.key(), it.key_size(),
+ it.value_position());
+ }
+
+ /**
+ * On serialization the values of each bucket (if has_mapped_type is true) are
+ * serialized next to the bucket. The potential old erased values in
+ * value_container are thus not serialized.
+ *
+ * On deserialization, when hash_compatible is true, we reaffect the value
+ * index (IndexSizeT) of each bucket with set_value as the position of each
+ * value is no more the same in value_container compared to when they were
+ * serialized.
+ *
+ * It's done this way as we can't call clear_old_erased_values() because we
+ * want the serialize method to remain const and we don't want to
+ * serialize/deserialize old erased values. As we may not serialize all the
+ * values in value_container, the values we keep can change of index. We thus
+ * have to modify the value indexes in the buckets.
+ */
+ template <class Serializer>
+ void serialize_impl(Serializer& serializer) const {
+ const slz_size_type version = SERIALIZATION_PROTOCOL_VERSION;
+ serializer(version);
+
+ const slz_size_type bucket_count = m_buckets_data.size();
+ serializer(bucket_count);
+
+ const slz_size_type nb_elements = m_nb_elements;
+ serializer(nb_elements);
+
+ const float max_load_factor = m_max_load_factor;
+ serializer(max_load_factor);
+
+ for (const array_bucket& bucket : m_buckets_data) {
+ bucket.serialize(serializer);
+ serialize_bucket_values(serializer, bucket);
+ }
+ }
+
+ template <
+ class Serializer, class U = T,
+ typename std::enable_if<!has_mapped_type<U>::value>::type* = nullptr>
+ void serialize_bucket_values(Serializer& /*serializer*/,
+ const array_bucket& /*bucket*/) const {}
+
+ template <class Serializer, class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ void serialize_bucket_values(Serializer& serializer,
+ const array_bucket& bucket) const {
+ for (auto it = bucket.begin(); it != bucket.end(); ++it) {
+ serializer(this->m_values[it.value()]);
+ }
+ }
+
+ template <class Deserializer>
+ void deserialize_impl(Deserializer& deserializer, bool hash_compatible) {
+ tsl_ah_assert(m_buckets_data.empty()); // Current hash table must be empty
+
+ const slz_size_type version =
+ deserialize_value<slz_size_type>(deserializer);
+ // For now we only have one version of the serialization protocol.
+ // If it doesn't match there is a problem with the file.
+ if (version != SERIALIZATION_PROTOCOL_VERSION) {
+ throw std::runtime_error(
+ "Can't deserialize the array_map/set. The protocol version header is "
+ "invalid.");
+ }
+
+ const slz_size_type bucket_count_ds =
+ deserialize_value<slz_size_type>(deserializer);
+ const slz_size_type nb_elements =
+ deserialize_value<slz_size_type>(deserializer);
+ const float max_load_factor = deserialize_value<float>(deserializer);
+
+ m_nb_elements = numeric_cast<IndexSizeT>(
+ nb_elements, "Deserialized nb_elements is too big.");
+
+ size_type bucket_count = numeric_cast<size_type>(
+ bucket_count_ds, "Deserialized bucket_count is too big.");
+ GrowthPolicy::operator=(GrowthPolicy(bucket_count));
+
+ this->max_load_factor(max_load_factor);
+ value_container<T>::reserve(m_nb_elements);
+
+ if (hash_compatible) {
+ if (bucket_count != bucket_count_ds) {
+ throw std::runtime_error(
+ "The GrowthPolicy is not the same even though hash_compatible is "
+ "true.");
+ }
+
+ m_buckets_data.reserve(bucket_count);
+ for (size_type i = 0; i < bucket_count; i++) {
+ m_buckets_data.push_back(array_bucket::deserialize(deserializer));
+ deserialize_bucket_values(deserializer, m_buckets_data.back());
+ }
+ } else {
+ m_buckets_data.resize(bucket_count);
+ for (size_type i = 0; i < bucket_count; i++) {
+ // TODO use buffer to avoid reallocation on each deserialization.
+ array_bucket bucket = array_bucket::deserialize(deserializer);
+ deserialize_bucket_values(deserializer, bucket);
+
+ for (auto it_val = bucket.cbegin(); it_val != bucket.cend(); ++it_val) {
+ const std::size_t ibucket =
+ bucket_for_hash(hash_key(it_val.key(), it_val.key_size()));
+
+ auto it_find = m_buckets_data[ibucket].find_or_end_of_bucket(
+ it_val.key(), it_val.key_size());
+ if (it_find.second) {
+ throw std::runtime_error(
+ "Error on deserialization, the same key is presents multiple "
+ "times.");
+ }
+
+ append_array_bucket_iterator_in_bucket(m_buckets_data[ibucket],
+ it_find.first, it_val);
+ }
+ }
+ }
+
+ m_buckets = m_buckets_data.data();
+
+ if (load_factor() > this->max_load_factor()) {
+ throw std::runtime_error(
+ "Invalid max_load_factor. Check that the serializer and deserializer "
+ "support "
+ "floats correctly as they can be converted implicitely to ints.");
+ }
+ }
+
+ template <
+ class Deserializer, class U = T,
+ typename std::enable_if<!has_mapped_type<U>::value>::type* = nullptr>
+ void deserialize_bucket_values(Deserializer& /*deserializer*/,
+ array_bucket& /*bucket*/) {}
+
+ template <class Deserializer, class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ void deserialize_bucket_values(Deserializer& deserializer,
+ array_bucket& bucket) {
+ for (auto it = bucket.begin(); it != bucket.end(); ++it) {
+ this->m_values.emplace_back(deserialize_value<U>(deserializer));
+
+ tsl_ah_assert(this->m_values.size() - 1 <=
+ std::numeric_limits<IndexSizeT>::max());
+ it.set_value(static_cast<IndexSizeT>(this->m_values.size() - 1));
+ }
+ }
+
+ template <class U = T, typename std::enable_if<
+ !has_mapped_type<U>::value>::type* = nullptr>
+ void append_array_bucket_iterator_in_bucket(
+ array_bucket& bucket, typename array_bucket::const_iterator end_of_bucket,
+ typename array_bucket::const_iterator it_val) {
+ bucket.append(end_of_bucket, it_val.key(), it_val.key_size());
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+ void append_array_bucket_iterator_in_bucket(
+ array_bucket& bucket, typename array_bucket::const_iterator end_of_bucket,
+ typename array_bucket::const_iterator it_val) {
+ bucket.append(end_of_bucket, it_val.key(), it_val.key_size(),
+ it_val.value());
+ }
+
+ public:
+ static const size_type DEFAULT_INIT_BUCKET_COUNT = 0;
+ static constexpr float DEFAULT_MAX_LOAD_FACTOR = 2.0f;
+ static const size_type MAX_KEY_SIZE = array_bucket::MAX_KEY_SIZE;
+
+ private:
+ /**
+ * Protocol version currenlty used for serialization.
+ */
+ static const slz_size_type SERIALIZATION_PROTOCOL_VERSION = 1;
+
+ static constexpr float DEFAULT_CLEAR_OLD_ERASED_VALUE_THRESHOLD = 0.6f;
+ static constexpr float REHASH_CLEAR_OLD_ERASED_VALUE_THRESHOLD = 0.9f;
+
+ /**
+ * Return an always valid pointer to a static empty array_bucket.
+ */
+ array_bucket* static_empty_bucket_ptr() {
+ static array_bucket empty_bucket;
+ return &empty_bucket;
+ }
+
+ private:
+ std::vector<array_bucket> m_buckets_data;
+
+ /**
+ * Points to m_buckets_data.data() if !m_buckets_data.empty() otherwise points
+ * to static_empty_bucket_ptr. This variable is useful to avoid the cost of
+ * checking if m_buckets_data is empty when trying to find an element.
+ *
+ * TODO Remove m_buckets_data and only use a pointer+size instead of a
+ * pointer+vector to save some space in the array_hash object.
+ */
+ array_bucket* m_buckets;
+
+ IndexSizeT m_nb_elements;
+ float m_max_load_factor;
+ size_type m_load_threshold;
+};
+
+} // end namespace detail_array_hash
+} // end namespace tsl
+
+#endif
diff --git a/include/tsl/array-hash/array_map.h b/include/tsl/array-hash/array_map.h
new file mode 100644
index 00000000..435fe03a
--- /dev/null
+++ b/include/tsl/array-hash/array_map.h
@@ -0,0 +1,929 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ARRAY_MAP_H
+#define TSL_ARRAY_MAP_H
+
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "array_hash.h"
+
+namespace tsl {
+
+/**
+ * Implementation of a cache-conscious string hash map.
+ *
+ * The map stores the strings as `const CharT*`. If `StoreNullTerminator` is
+ * true, the strings are stored with the a null-terminator (the `key()` method
+ * of the iterators will return a pointer to this null-terminated string).
+ * Otherwise the null character is not stored (which allow an economy of 1 byte
+ * per string).
+ *
+ * The value `T` must be either nothrow move-constructible, copy-constructible
+ * or both.
+ *
+ * The size of a key string is limited to `std::numeric_limits<KeySizeT>::max()
+ * - 1`. That is 65 535 characters by default, but can be raised with the
+ * `KeySizeT` template parameter. See `max_key_size()` for an easy access to
+ * this limit.
+ *
+ * The number of elements in the map is limited to
+ * `std::numeric_limits<IndexSizeT>::max()`. That is 4 294 967 296 elements, but
+ * can be raised with the `IndexSizeT` template parameter. See `max_size()` for
+ * an easy access to this limit.
+ *
+ * Iterators invalidation:
+ * - clear, operator=: always invalidate the iterators.
+ * - insert, emplace, operator[]: always invalidate the iterators.
+ * - erase: always invalidate the iterators.
+ * - shrink_to_fit: always invalidate the iterators.
+ */
+template <class CharT, class T, class Hash = tsl::ah::str_hash<CharT>,
+ class KeyEqual = tsl::ah::str_equal<CharT>,
+ bool StoreNullTerminator = true, class KeySizeT = std::uint16_t,
+ class IndexSizeT = std::uint32_t,
+ class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>
+class array_map {
+ private:
+ template <typename U>
+ using is_iterator = tsl::detail_array_hash::is_iterator<U>;
+
+ using ht = tsl::detail_array_hash::array_hash<CharT, T, Hash, KeyEqual,
+ StoreNullTerminator, KeySizeT,
+ IndexSizeT, GrowthPolicy>;
+
+ public:
+ using char_type = typename ht::char_type;
+ using mapped_type = T;
+ using key_size_type = typename ht::key_size_type;
+ using index_size_type = typename ht::index_size_type;
+ using size_type = typename ht::size_type;
+ using hasher = typename ht::hasher;
+ using key_equal = typename ht::key_equal;
+ using iterator = typename ht::iterator;
+ using const_iterator = typename ht::const_iterator;
+
+ public:
+ array_map() : array_map(ht::DEFAULT_INIT_BUCKET_COUNT) {}
+
+ explicit array_map(size_type bucket_count, const Hash& hash = Hash())
+ : m_ht(bucket_count, hash, ht::DEFAULT_MAX_LOAD_FACTOR) {}
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ array_map(InputIt first, InputIt last,
+ size_type bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT,
+ const Hash& hash = Hash())
+ : array_map(bucket_count, hash) {
+ insert(first, last);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ array_map(
+ std::initializer_list<std::pair<std::basic_string_view<CharT>, T>> init,
+ size_type bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT,
+ const Hash& hash = Hash())
+ : array_map(bucket_count, hash) {
+ insert(init);
+ }
+#else
+ array_map(std::initializer_list<std::pair<const CharT*, T>> init,
+ size_type bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT,
+ const Hash& hash = Hash())
+ : array_map(bucket_count, hash) {
+ insert(init);
+ }
+#endif
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ array_map& operator=(
+ std::initializer_list<std::pair<std::basic_string_view<CharT>, T>>
+ ilist) {
+ clear();
+
+ reserve(ilist.size());
+ insert(ilist);
+
+ return *this;
+ }
+#else
+ array_map& operator=(
+ std::initializer_list<std::pair<const CharT*, T>> ilist) {
+ clear();
+
+ reserve(ilist.size());
+ insert(ilist);
+
+ return *this;
+ }
+#endif
+
+ /*
+ * Iterators
+ */
+ iterator begin() noexcept { return m_ht.begin(); }
+ const_iterator begin() const noexcept { return m_ht.begin(); }
+ const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
+
+ iterator end() noexcept { return m_ht.end(); }
+ const_iterator end() const noexcept { return m_ht.end(); }
+ const_iterator cend() const noexcept { return m_ht.cend(); }
+
+ /*
+ * Capacity
+ */
+ bool empty() const noexcept { return m_ht.empty(); }
+ size_type size() const noexcept { return m_ht.size(); }
+ size_type max_size() const noexcept { return m_ht.max_size(); }
+ size_type max_key_size() const noexcept { return m_ht.max_key_size(); }
+ void shrink_to_fit() { m_ht.shrink_to_fit(); }
+
+ /*
+ * Modifiers
+ */
+ void clear() noexcept { m_ht.clear(); }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::pair<iterator, bool> insert(const std::basic_string_view<CharT>& key,
+ const T& value) {
+ return m_ht.emplace(key.data(), key.size(), value);
+ }
+#else
+ std::pair<iterator, bool> insert(const CharT* key, const T& value) {
+ return m_ht.emplace(key, std::char_traits<CharT>::length(key), value);
+ }
+
+ std::pair<iterator, bool> insert(const std::basic_string<CharT>& key,
+ const T& value) {
+ return m_ht.emplace(key.data(), key.size(), value);
+ }
+#endif
+ std::pair<iterator, bool> insert_ks(const CharT* key, size_type key_size,
+ const T& value) {
+ return m_ht.emplace(key, key_size, value);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::pair<iterator, bool> insert(const std::basic_string_view<CharT>& key,
+ T&& value) {
+ return m_ht.emplace(key.data(), key.size(), std::move(value));
+ }
+#else
+ std::pair<iterator, bool> insert(const CharT* key, T&& value) {
+ return m_ht.emplace(key, std::char_traits<CharT>::length(key),
+ std::move(value));
+ }
+
+ std::pair<iterator, bool> insert(const std::basic_string<CharT>& key,
+ T&& value) {
+ return m_ht.emplace(key.data(), key.size(), std::move(value));
+ }
+#endif
+ std::pair<iterator, bool> insert_ks(const CharT* key, size_type key_size,
+ T&& value) {
+ return m_ht.emplace(key, key_size, std::move(value));
+ }
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ void insert(InputIt first, InputIt last) {
+ if (std::is_base_of<
+ std::forward_iterator_tag,
+ typename std::iterator_traits<InputIt>::iterator_category>::value) {
+ const auto nb_elements_insert = std::distance(first, last);
+ const std::size_t nb_free_buckets =
+ std::size_t(float(bucket_count()) * max_load_factor()) - size();
+
+ if (nb_elements_insert > 0 &&
+ nb_free_buckets < std::size_t(nb_elements_insert)) {
+ reserve(size() + std::size_t(nb_elements_insert));
+ }
+ }
+
+ for (auto it = first; it != last; ++it) {
+ insert_pair(*it);
+ }
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ void insert(std::initializer_list<std::pair<std::basic_string_view<CharT>, T>>
+ ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#else
+ void insert(std::initializer_list<std::pair<const CharT*, T>> ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#endif
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ template <class M>
+ std::pair<iterator, bool> insert_or_assign(
+ const std::basic_string_view<CharT>& key, M&& obj) {
+ return m_ht.insert_or_assign(key.data(), key.size(), std::forward<M>(obj));
+ }
+#else
+ template <class M>
+ std::pair<iterator, bool> insert_or_assign(const CharT* key, M&& obj) {
+ return m_ht.insert_or_assign(key, std::char_traits<CharT>::length(key),
+ std::forward<M>(obj));
+ }
+
+ template <class M>
+ std::pair<iterator, bool> insert_or_assign(
+ const std::basic_string<CharT>& key, M&& obj) {
+ return m_ht.insert_or_assign(key.data(), key.size(), std::forward<M>(obj));
+ }
+#endif
+ template <class M>
+ std::pair<iterator, bool> insert_or_assign_ks(const CharT* key,
+ size_type key_size, M&& obj) {
+ return m_ht.insert_or_assign(key, key_size, std::forward<M>(obj));
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ template <class... Args>
+ std::pair<iterator, bool> emplace(const std::basic_string_view<CharT>& key,
+ Args&&... args) {
+ return m_ht.emplace(key.data(), key.size(), std::forward<Args>(args)...);
+ }
+#else
+ template <class... Args>
+ std::pair<iterator, bool> emplace(const CharT* key, Args&&... args) {
+ return m_ht.emplace(key, std::char_traits<CharT>::length(key),
+ std::forward<Args>(args)...);
+ }
+
+ template <class... Args>
+ std::pair<iterator, bool> emplace(const std::basic_string<CharT>& key,
+ Args&&... args) {
+ return m_ht.emplace(key.data(), key.size(), std::forward<Args>(args)...);
+ }
+#endif
+ template <class... Args>
+ std::pair<iterator, bool> emplace_ks(const CharT* key, size_type key_size,
+ Args&&... args) {
+ return m_ht.emplace(key, key_size, std::forward<Args>(args)...);
+ }
+
+ /**
+ * Erase has an amortized O(1) runtime complexity, but even if it removes the
+ * key immediately, it doesn't do the same for the associated value T.
+ *
+ * T will only be removed when the ratio between the size of the map and
+ * the size of the map + the number of deleted values still stored is low
+ * enough.
+ *
+ * To force the deletion you can call shrink_to_fit.
+ */
+ iterator erase(const_iterator pos) { return m_ht.erase(pos); }
+
+ /**
+ * @copydoc erase(const_iterator pos)
+ */
+ iterator erase(const_iterator first, const_iterator last) {
+ return m_ht.erase(first, last);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc erase(const_iterator pos)
+ */
+ size_type erase(const std::basic_string_view<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#else
+ /**
+ * @copydoc erase(const_iterator pos)
+ */
+ size_type erase(const CharT* key) {
+ return m_ht.erase(key, std::char_traits<CharT>::length(key));
+ }
+
+ /**
+ * @copydoc erase(const_iterator pos)
+ */
+ size_type erase(const std::basic_string<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#endif
+ /**
+ * @copydoc erase(const_iterator pos)
+ */
+ size_type erase_ks(const CharT* key, size_type key_size) {
+ return m_ht.erase(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc erase_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ size_type erase(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.erase(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc erase_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ size_type erase(const CharT* key, std::size_t precalculated_hash) {
+ return m_ht.erase(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc erase_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ size_type erase(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.erase(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * @copydoc erase(const_iterator pos)
+ *
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ size_type erase_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.erase(key, key_size, precalculated_hash);
+ }
+
+ void swap(array_map& other) { other.m_ht.swap(m_ht); }
+
+ /*
+ * Lookup
+ */
+#ifdef TSL_AH_HAS_STRING_VIEW
+ T& at(const std::basic_string_view<CharT>& key) {
+ return m_ht.at(key.data(), key.size());
+ }
+
+ const T& at(const std::basic_string_view<CharT>& key) const {
+ return m_ht.at(key.data(), key.size());
+ }
+#else
+ T& at(const CharT* key) {
+ return m_ht.at(key, std::char_traits<CharT>::length(key));
+ }
+
+ const T& at(const CharT* key) const {
+ return m_ht.at(key, std::char_traits<CharT>::length(key));
+ }
+
+ T& at(const std::basic_string<CharT>& key) {
+ return m_ht.at(key.data(), key.size());
+ }
+
+ const T& at(const std::basic_string<CharT>& key) const {
+ return m_ht.at(key.data(), key.size());
+ }
+#endif
+ T& at_ks(const CharT* key, size_type key_size) {
+ return m_ht.at(key, key_size);
+ }
+
+ const T& at_ks(const CharT* key, size_type key_size) const {
+ return m_ht.at(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ T& at(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.at(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const T& at(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.at(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ T& at(const CharT* key, std::size_t precalculated_hash) {
+ return m_ht.at(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const T& at(const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.at(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ T& at(const std::basic_string<CharT>& key, std::size_t precalculated_hash) {
+ return m_ht.at(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const T& at(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.at(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ T& at_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.at(key, key_size, precalculated_hash);
+ }
+
+ /**
+ * @copydoc at_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const T& at_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.at(key, key_size, precalculated_hash);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ T& operator[](const std::basic_string_view<CharT>& key) {
+ return m_ht.access_operator(key.data(), key.size());
+ }
+#else
+ T& operator[](const CharT* key) {
+ return m_ht.access_operator(key, std::char_traits<CharT>::length(key));
+ }
+ T& operator[](const std::basic_string<CharT>& key) {
+ return m_ht.access_operator(key.data(), key.size());
+ }
+#endif
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ size_type count(const std::basic_string_view<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#else
+ size_type count(const CharT* key) const {
+ return m_ht.count(key, std::char_traits<CharT>::length(key));
+ }
+
+ size_type count(const std::basic_string<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#endif
+ size_type count_ks(const CharT* key, size_type key_size) const {
+ return m_ht.count(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc count_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash) const
+ */
+ size_type count(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.count(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc count_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash) const
+ */
+ size_type count(const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.count(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc count_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash) const
+ */
+ size_type count(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.count(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ size_type count_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.count(key, key_size, precalculated_hash);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ iterator find(const std::basic_string_view<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string_view<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#else
+ iterator find(const CharT* key) {
+ return m_ht.find(key, std::char_traits<CharT>::length(key));
+ }
+
+ const_iterator find(const CharT* key) const {
+ return m_ht.find(key, std::char_traits<CharT>::length(key));
+ }
+
+ iterator find(const std::basic_string<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#endif
+ iterator find_ks(const CharT* key, size_type key_size) {
+ return m_ht.find(key, key_size);
+ }
+
+ const_iterator find_ks(const CharT* key, size_type key_size) const {
+ return m_ht.find(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ iterator find(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ iterator find(const CharT* key, std::size_t precalculated_hash) {
+ return m_ht.find(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find(const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.find(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ iterator find(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ iterator find_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.find(key, key_size, precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.find(key, key_size, precalculated_hash);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string_view<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string_view<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, iterator> equal_range(const CharT* key) {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key) const {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key));
+ }
+
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#endif
+ std::pair<iterator, iterator> equal_range_ks(const CharT* key,
+ size_type key_size) {
+ return m_ht.equal_range(key, key_size);
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range_ks(
+ const CharT* key, size_type key_size) const {
+ return m_ht.equal_range(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<iterator, iterator> equal_range(const CharT* key,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<iterator, iterator> equal_range(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ std::pair<iterator, iterator> equal_range_ks(const CharT* key,
+ size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key, key_size, precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range_ks(
+ const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key, key_size, precalculated_hash);
+ }
+
+ /*
+ * Bucket interface
+ */
+ size_type bucket_count() const { return m_ht.bucket_count(); }
+ size_type max_bucket_count() const { return m_ht.max_bucket_count(); }
+
+ /*
+ * Hash policy
+ */
+ float load_factor() const { return m_ht.load_factor(); }
+ float max_load_factor() const { return m_ht.max_load_factor(); }
+ void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
+
+ void rehash(size_type count) { m_ht.rehash(count); }
+ void reserve(size_type count) { m_ht.reserve(count); }
+
+ /*
+ * Observers
+ */
+ hasher hash_function() const { return m_ht.hash_function(); }
+ key_equal key_eq() const { return m_ht.key_eq(); }
+
+ /*
+ * Other
+ */
+ /**
+ * Return the `const_iterator it` as an `iterator`.
+ */
+ iterator mutable_iterator(const_iterator it) noexcept {
+ return m_ht.mutable_iterator(it);
+ }
+
+ /**
+ * Serialize the map through the `serializer` parameter.
+ *
+ * The `serializer` parameter must be a function object that supports the
+ * following calls:
+ * - `template<typename U> void operator()(const U& value);` where the types
+ * `std::uint64_t`, `float` and `T` must be supported for U.
+ * - `void operator()(const CharT* value, std::size_t value_size);`
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, ...) of the types it serializes in the hands of the `Serializer`
+ * function object if compatibility is required.
+ */
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ m_ht.serialize(serializer);
+ }
+
+ /**
+ * Deserialize a previously serialized map through the `deserializer`
+ * parameter.
+ *
+ * The `deserializer` parameter must be a function object that supports the
+ * following calls:
+ * - `template<typename U> U operator()();` where the types `std::uint64_t`,
+ * `float` and `T` must be supported for U.
+ * - `void operator()(CharT* value_out, std::size_t value_size);`
+ *
+ * If the deserialized hash map type is hash compatible with the serialized
+ * map, the deserialization process can be sped up by setting
+ * `hash_compatible` to true. To be hash compatible, the Hash (take care of
+ * the 32-bits vs 64 bits), KeyEqual, GrowthPolicy, StoreNullTerminator,
+ * KeySizeT and IndexSizeT must behave the same than the ones used on the
+ * serialized map. Otherwise the behaviour is undefined with `hash_compatible`
+ * sets to true.
+ *
+ * The behaviour is undefined if the type `CharT` and `T` of the `array_map`
+ * are not the same as the types used during serialization.
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, size of int, ...) of the types it deserializes in the hands of the
+ * `Deserializer` function object if compatibility is required.
+ */
+ template <class Deserializer>
+ static array_map deserialize(Deserializer& deserializer,
+ bool hash_compatible = false) {
+ array_map map(0);
+ map.m_ht.deserialize(deserializer, hash_compatible);
+
+ return map;
+ }
+
+ friend bool operator==(const array_map& lhs, const array_map& rhs) {
+ if (lhs.size() != rhs.size()) {
+ return false;
+ }
+
+ for (auto it = lhs.cbegin(); it != lhs.cend(); ++it) {
+ const auto it_element_rhs = rhs.find_ks(it.key(), it.key_size());
+ if (it_element_rhs == rhs.cend() ||
+ it.value() != it_element_rhs.value()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ friend bool operator!=(const array_map& lhs, const array_map& rhs) {
+ return !operator==(lhs, rhs);
+ }
+
+ friend void swap(array_map& lhs, array_map& rhs) { lhs.swap(rhs); }
+
+ private:
+ template <class U, class V>
+ void insert_pair(const std::pair<U, V>& value) {
+ insert(value.first, value.second);
+ }
+
+ template <class U, class V>
+ void insert_pair(std::pair<U, V>&& value) {
+ insert(value.first, std::move(value.second));
+ }
+
+ public:
+ static const size_type MAX_KEY_SIZE = ht::MAX_KEY_SIZE;
+
+ private:
+ ht m_ht;
+};
+
+/**
+ * Same as
+ * `tsl::array_map<CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT,
+ * IndexSizeT, tsl::ah::prime_growth_policy>`.
+ */
+template <class CharT, class T, class Hash = tsl::ah::str_hash<CharT>,
+ class KeyEqual = tsl::ah::str_equal<CharT>,
+ bool StoreNullTerminator = true, class KeySizeT = std::uint16_t,
+ class IndexSizeT = std::uint32_t>
+using array_pg_map =
+ array_map<CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT,
+ IndexSizeT, tsl::ah::prime_growth_policy>;
+
+} // end namespace tsl
+
+#endif
diff --git a/include/tsl/array-hash/array_set.h b/include/tsl/array-hash/array_set.h
new file mode 100644
index 00000000..f6fb0167
--- /dev/null
+++ b/include/tsl/array-hash/array_set.h
@@ -0,0 +1,716 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ARRAY_SET_H
+#define TSL_ARRAY_SET_H
+
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "array_hash.h"
+
+namespace tsl {
+
+/**
+ * Implementation of a cache-conscious string hash set.
+ *
+ * The set stores the strings as `const CharT*`. If `StoreNullTerminator` is
+ * true, the strings are stored with the a null-terminator (the `key()` method
+ * of the iterators will return a pointer to this null-terminated string).
+ * Otherwise the null character is not stored (which allow an economy of 1 byte
+ * per string).
+ *
+ * The size of a key string is limited to `std::numeric_limits<KeySizeT>::max()
+ * - 1`. That is 65 535 characters by default, but can be raised with the
+ * `KeySizeT` template parameter. See `max_key_size()` for an easy access to
+ * this limit.
+ *
+ * The number of elements in the set is limited to
+ * `std::numeric_limits<IndexSizeT>::max()`. That is 4 294 967 296 elements, but
+ * can be raised with the `IndexSizeT` template parameter. See `max_size()` for
+ * an easy access to this limit.
+ *
+ * Iterators invalidation:
+ * - clear, operator=: always invalidate the iterators.
+ * - insert, emplace, operator[]: always invalidate the iterators.
+ * - erase: always invalidate the iterators.
+ * - shrink_to_fit: always invalidate the iterators.
+ */
+template <class CharT, class Hash = tsl::ah::str_hash<CharT>,
+ class KeyEqual = tsl::ah::str_equal<CharT>,
+ bool StoreNullTerminator = true, class KeySizeT = std::uint16_t,
+ class IndexSizeT = std::uint32_t,
+ class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>
+class array_set {
+ private:
+ template <typename U>
+ using is_iterator = tsl::detail_array_hash::is_iterator<U>;
+
+ using ht = tsl::detail_array_hash::array_hash<CharT, void, Hash, KeyEqual,
+ StoreNullTerminator, KeySizeT,
+ IndexSizeT, GrowthPolicy>;
+
+ public:
+ using char_type = typename ht::char_type;
+ using key_size_type = typename ht::key_size_type;
+ using index_size_type = typename ht::index_size_type;
+ using size_type = typename ht::size_type;
+ using hasher = typename ht::hasher;
+ using key_equal = typename ht::key_equal;
+ using iterator = typename ht::iterator;
+ using const_iterator = typename ht::const_iterator;
+
+ array_set() : array_set(ht::DEFAULT_INIT_BUCKET_COUNT) {}
+
+ explicit array_set(size_type bucket_count, const Hash& hash = Hash())
+ : m_ht(bucket_count, hash, ht::DEFAULT_MAX_LOAD_FACTOR) {}
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ array_set(InputIt first, InputIt last,
+ size_type bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT,
+ const Hash& hash = Hash())
+ : array_set(bucket_count, hash) {
+ insert(first, last);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ array_set(std::initializer_list<std::basic_string_view<CharT>> init,
+ size_type bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT,
+ const Hash& hash = Hash())
+ : array_set(bucket_count, hash) {
+ insert(init);
+ }
+#else
+ array_set(std::initializer_list<const CharT*> init,
+ size_type bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT,
+ const Hash& hash = Hash())
+ : array_set(bucket_count, hash) {
+ insert(init);
+ }
+#endif
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ array_set& operator=(
+ std::initializer_list<std::basic_string_view<CharT>> ilist) {
+ clear();
+
+ reserve(ilist.size());
+ insert(ilist);
+
+ return *this;
+ }
+#else
+ array_set& operator=(std::initializer_list<const CharT*> ilist) {
+ clear();
+
+ reserve(ilist.size());
+ insert(ilist);
+
+ return *this;
+ }
+#endif
+
+ /*
+ * Iterators
+ */
+ iterator begin() noexcept { return m_ht.begin(); }
+ const_iterator begin() const noexcept { return m_ht.begin(); }
+ const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
+
+ iterator end() noexcept { return m_ht.end(); }
+ const_iterator end() const noexcept { return m_ht.end(); }
+ const_iterator cend() const noexcept { return m_ht.cend(); }
+
+ /*
+ * Capacity
+ */
+ bool empty() const noexcept { return m_ht.empty(); }
+ size_type size() const noexcept { return m_ht.size(); }
+ size_type max_size() const noexcept { return m_ht.max_size(); }
+ size_type max_key_size() const noexcept { return m_ht.max_key_size(); }
+ void shrink_to_fit() { m_ht.shrink_to_fit(); }
+
+ /*
+ * Modifiers
+ */
+ void clear() noexcept { m_ht.clear(); }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::pair<iterator, bool> insert(const std::basic_string_view<CharT>& key) {
+ return m_ht.emplace(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, bool> insert(const CharT* key) {
+ return m_ht.emplace(key, std::char_traits<CharT>::length(key));
+ }
+
+ std::pair<iterator, bool> insert(const std::basic_string<CharT>& key) {
+ return m_ht.emplace(key.data(), key.size());
+ }
+#endif
+ std::pair<iterator, bool> insert_ks(const CharT* key, size_type key_size) {
+ return m_ht.emplace(key, key_size);
+ }
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ void insert(InputIt first, InputIt last) {
+ if (std::is_base_of<
+ std::forward_iterator_tag,
+ typename std::iterator_traits<InputIt>::iterator_category>::value) {
+ const auto nb_elements_insert = std::distance(first, last);
+ const std::size_t nb_free_buckets =
+ std::size_t(float(bucket_count()) * max_load_factor()) - size();
+
+ if (nb_elements_insert > 0 &&
+ nb_free_buckets < std::size_t(nb_elements_insert)) {
+ reserve(size() + std::size_t(nb_elements_insert));
+ }
+ }
+
+ for (auto it = first; it != last; ++it) {
+ insert(*it);
+ }
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ void insert(std::initializer_list<std::basic_string_view<CharT>> ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#else
+ void insert(std::initializer_list<const CharT*> ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#endif
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc emplace_ks(const CharT* key, size_type key_size)
+ */
+ std::pair<iterator, bool> emplace(const std::basic_string_view<CharT>& key) {
+ return m_ht.emplace(key.data(), key.size());
+ }
+#else
+ /**
+ * @copydoc emplace_ks(const CharT* key, size_type key_size)
+ */
+ std::pair<iterator, bool> emplace(const CharT* key) {
+ return m_ht.emplace(key, std::char_traits<CharT>::length(key));
+ }
+
+ /**
+ * @copydoc emplace_ks(const CharT* key, size_type key_size)
+ */
+ std::pair<iterator, bool> emplace(const std::basic_string<CharT>& key) {
+ return m_ht.emplace(key.data(), key.size());
+ }
+#endif
+ /**
+ * No difference compared to the insert method. Mainly here for coherence with
+ * array_map.
+ */
+ std::pair<iterator, bool> emplace_ks(const CharT* key, size_type key_size) {
+ return m_ht.emplace(key, key_size);
+ }
+
+ iterator erase(const_iterator pos) { return m_ht.erase(pos); }
+ iterator erase(const_iterator first, const_iterator last) {
+ return m_ht.erase(first, last);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ size_type erase(const std::basic_string_view<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#else
+ size_type erase(const CharT* key) {
+ return m_ht.erase(key, std::char_traits<CharT>::length(key));
+ }
+
+ size_type erase(const std::basic_string<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#endif
+ size_type erase_ks(const CharT* key, size_type key_size) {
+ return m_ht.erase(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc erase_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ size_type erase(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.erase(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc erase_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ size_type erase(const CharT* key, std::size_t precalculated_hash) {
+ return m_ht.erase(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc erase_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ size_type erase(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.erase(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ size_type erase_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.erase(key, key_size, precalculated_hash);
+ }
+
+ void swap(array_set& other) { other.m_ht.swap(m_ht); }
+
+ /*
+ * Lookup
+ */
+#ifdef TSL_AH_HAS_STRING_VIEW
+ size_type count(const std::basic_string_view<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#else
+ size_type count(const CharT* key) const {
+ return m_ht.count(key, std::char_traits<CharT>::length(key));
+ }
+ size_type count(const std::basic_string<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#endif
+ size_type count_ks(const CharT* key, size_type key_size) const {
+ return m_ht.count(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc count_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash) const
+ */
+ size_type count(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.count(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc count_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash) const
+ */
+ size_type count(const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.count(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc count_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash) const
+ */
+ size_type count(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.count(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ size_type count_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.count(key, key_size, precalculated_hash);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ iterator find(const std::basic_string_view<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string_view<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#else
+ iterator find(const CharT* key) {
+ return m_ht.find(key, std::char_traits<CharT>::length(key));
+ }
+
+ const_iterator find(const CharT* key) const {
+ return m_ht.find(key, std::char_traits<CharT>::length(key));
+ }
+
+ iterator find(const std::basic_string<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#endif
+ iterator find_ks(const CharT* key, size_type key_size) {
+ return m_ht.find(key, key_size);
+ }
+
+ const_iterator find_ks(const CharT* key, size_type key_size) const {
+ return m_ht.find(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ iterator find(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find(const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ iterator find(const CharT* key, std::size_t precalculated_hash) {
+ return m_ht.find(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find(const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.find(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ iterator find(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.find(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ iterator find_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.find(key, key_size, precalculated_hash);
+ }
+
+ /**
+ * @copydoc find_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ const_iterator find_ks(const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.find(key, key_size, precalculated_hash);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string_view<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string_view<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, iterator> equal_range(const CharT* key) {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key) const {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key));
+ }
+
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#endif
+ std::pair<iterator, iterator> equal_range_ks(const CharT* key,
+ size_type key_size) {
+ return m_ht.equal_range(key, key_size);
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range_ks(
+ const CharT* key, size_type key_size) const {
+ return m_ht.equal_range(key, key_size);
+ }
+
+#ifdef TSL_AH_HAS_STRING_VIEW
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string_view<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+#else
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<iterator, iterator> equal_range(const CharT* key,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key, std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key, std::char_traits<CharT>::length(key),
+ precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<iterator, iterator> equal_range(const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string<CharT>& key,
+ std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key.data(), key.size(), precalculated_hash);
+ }
+#endif
+ /**
+ * Use the hash value 'precalculated_hash' instead of hashing the key. The
+ * hash value should be the same as hash_function()(key). Useful to speed-up
+ * the lookup to the value if you already have the hash.
+ */
+ std::pair<iterator, iterator> equal_range_ks(const CharT* key,
+ size_type key_size,
+ std::size_t precalculated_hash) {
+ return m_ht.equal_range(key, key_size, precalculated_hash);
+ }
+
+ /**
+ * @copydoc equal_range_ks(const CharT* key, size_type key_size, std::size_t
+ * precalculated_hash)
+ */
+ std::pair<const_iterator, const_iterator> equal_range_ks(
+ const CharT* key, size_type key_size,
+ std::size_t precalculated_hash) const {
+ return m_ht.equal_range(key, key_size, precalculated_hash);
+ }
+
+ /*
+ * Bucket interface
+ */
+ size_type bucket_count() const { return m_ht.bucket_count(); }
+ size_type max_bucket_count() const { return m_ht.max_bucket_count(); }
+
+ /*
+ * Hash policy
+ */
+ float load_factor() const { return m_ht.load_factor(); }
+ float max_load_factor() const { return m_ht.max_load_factor(); }
+ void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
+
+ void rehash(size_type count) { m_ht.rehash(count); }
+ void reserve(size_type count) { m_ht.reserve(count); }
+
+ /*
+ * Observers
+ */
+ hasher hash_function() const { return m_ht.hash_function(); }
+ key_equal key_eq() const { return m_ht.key_eq(); }
+
+ /*
+ * Other
+ */
+ /**
+ * Return the `const_iterator it` as an `iterator`.
+ */
+ iterator mutable_iterator(const_iterator it) noexcept {
+ return m_ht.mutable_iterator(it);
+ }
+
+ /**
+ * Serialize the set through the `serializer` parameter.
+ *
+ * The `serializer` parameter must be a function object that supports the
+ * following calls:
+ * - `template<typename U> void operator()(const U& value);` where the types
+ * `std::uint64_t` and `float` must be supported for U.
+ * - `void operator()(const CharT* value, std::size_t value_size);`
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, ...) of the types it serializes in the hands of the `Serializer`
+ * function object if compatibility is required.
+ */
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ m_ht.serialize(serializer);
+ }
+
+ /**
+ * Deserialize a previously serialized set through the `deserializer`
+ * parameter.
+ *
+ * The `deserializer` parameter must be a function object that supports the
+ * following calls:
+ * - `template<typename U> U operator()();` where the types `std::uint64_t`
+ * and `float` must be supported for U.
+ * - `void operator()(CharT* value_out, std::size_t value_size);`
+ *
+ * If the deserialized hash set type is hash compatible with the serialized
+ * set, the deserialization process can be sped up by setting
+ * `hash_compatible` to true. To be hash compatible, the Hash (take care of
+ * the 32-bits vs 64 bits), KeyEqual, GrowthPolicy, StoreNullTerminator,
+ * KeySizeT and IndexSizeT must behave the same than the ones used on the
+ * serialized set. Otherwise the behaviour is undefined with `hash_compatible`
+ * sets to true.
+ *
+ * The behaviour is undefined if the type `CharT` of the `array_set` is not
+ * the same as the type used during serialization.
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, size of int, ...) of the types it deserializes in the hands of the
+ * `Deserializer` function object if compatibility is required.
+ */
+ template <class Deserializer>
+ static array_set deserialize(Deserializer& deserializer,
+ bool hash_compatible = false) {
+ array_set set(0);
+ set.m_ht.deserialize(deserializer, hash_compatible);
+
+ return set;
+ }
+
+ friend bool operator==(const array_set& lhs, const array_set& rhs) {
+ if (lhs.size() != rhs.size()) {
+ return false;
+ }
+
+ for (auto it = lhs.cbegin(); it != lhs.cend(); ++it) {
+ const auto it_element_rhs = rhs.find_ks(it.key(), it.key_size());
+ if (it_element_rhs == rhs.cend()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ friend bool operator!=(const array_set& lhs, const array_set& rhs) {
+ return !operator==(lhs, rhs);
+ }
+
+ friend void swap(array_set& lhs, array_set& rhs) { lhs.swap(rhs); }
+
+ public:
+ static const size_type MAX_KEY_SIZE = ht::MAX_KEY_SIZE;
+
+ private:
+ ht m_ht;
+};
+
+/**
+ * Same as
+ * `tsl::array_set<CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT,
+ * IndexSizeT, tsl::ah::prime_growth_policy>`.
+ */
+template <class CharT, class Hash = tsl::ah::str_hash<CharT>,
+ class KeyEqual = tsl::ah::str_equal<CharT>,
+ bool StoreNullTerminator = true, class KeySizeT = std::uint16_t,
+ class IndexSizeT = std::uint32_t>
+using array_pg_set =
+ array_set<CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT,
+ tsl::ah::prime_growth_policy>;
+
+} // end namespace tsl
+
+#endif
diff --git a/include/tsl/htrie_hash.h b/include/tsl/htrie_hash.h
new file mode 100644
index 00000000..0cf4632a
--- /dev/null
+++ b/include/tsl/htrie_hash.h
@@ -0,0 +1,2076 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_HTRIE_HASH_H
+#define TSL_HTRIE_HASH_H
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "array-hash/array_map.h"
+#include "array-hash/array_set.h"
+
+/*
+ * __has_include is a bit useless
+ * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79433), check also __cplusplus
+ * version.
+ */
+#ifdef __has_include
+#if __has_include(<string_view>) && (__cplusplus >= 201703L || _MSVC_LANG >= 201703L)
+#define TSL_HT_HAS_STRING_VIEW
+#endif
+#endif
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef TSL_DEBUG
+#define tsl_ht_assert(expr) assert(expr)
+#else
+#define tsl_ht_assert(expr) (static_cast<void>(0))
+#endif
+
+namespace tsl {
+
+namespace detail_htrie_hash {
+
+template <typename T, typename = void>
+struct is_iterator : std::false_type {};
+
+template <typename T>
+struct is_iterator<T, typename std::enable_if<!std::is_same<
+ typename std::iterator_traits<T>::iterator_category,
+ void>::value>::type> : std::true_type {};
+
+template <typename T, typename... U>
+struct is_related : std::false_type {};
+
+template <typename T, typename U>
+struct is_related<T, U>
+ : std::is_same<typename std::remove_cv<
+ typename std::remove_reference<T>::type>::type,
+ typename std::remove_cv<
+ typename std::remove_reference<U>::type>::type> {};
+
+template <typename T, typename U>
+static T numeric_cast(U value,
+ const char* error_message = "numeric_cast() failed.") {
+ T ret = static_cast<T>(value);
+ if (static_cast<U>(ret) != value) {
+ throw std::runtime_error(error_message);
+ }
+
+ const bool is_same_signedness =
+ (std::is_unsigned<T>::value && std::is_unsigned<U>::value) ||
+ (std::is_signed<T>::value && std::is_signed<U>::value);
+ if (!is_same_signedness && (ret < T{}) != (value < U{})) {
+ throw std::runtime_error(error_message);
+ }
+
+ return ret;
+}
+
+template <class T>
+struct value_node {
+ /*
+ * Avoid conflict with copy constructor 'value_node(const value_node&)'. If we
+ * call the copy constructor with a mutable reference
+ * 'value_node(value_node&)', we don't want the forward constructor to be
+ * called.
+ */
+ template <class... Args, typename std::enable_if<!is_related<
+ value_node, Args...>::value>::type* = nullptr>
+ value_node(Args&&... args) : m_value(std::forward<Args>(args)...) {}
+
+ T m_value;
+};
+
+template <>
+struct value_node<void> {};
+
+/**
+ * T should be void if there is no value associated to a key (in a set for
+ * example).
+ */
+template <class CharT, class T, class Hash, class KeySizeT>
+class htrie_hash {
+ private:
+ template <typename U>
+ using has_value =
+ typename std::integral_constant<bool, !std::is_same<U, void>::value>;
+
+ static_assert(std::is_same<CharT, char>::value,
+ "char is the only supported CharT type for now.");
+
+ static const std::size_t ALPHABET_SIZE =
+ std::numeric_limits<typename std::make_unsigned<CharT>::type>::max() + 1;
+
+ public:
+ template <bool IsConst, bool IsPrefixIterator>
+ class htrie_hash_iterator;
+
+ using char_type = CharT;
+ using key_size_type = KeySizeT;
+ using size_type = std::size_t;
+ using hasher = Hash;
+ using iterator = htrie_hash_iterator<false, false>;
+ using const_iterator = htrie_hash_iterator<true, false>;
+ using prefix_iterator = htrie_hash_iterator<false, true>;
+ using const_prefix_iterator = htrie_hash_iterator<true, true>;
+
+ private:
+ using array_hash_type = typename std::conditional<
+ has_value<T>::value,
+ tsl::array_map<CharT, T, Hash, tsl::ah::str_equal<CharT>, false, KeySizeT,
+ std::uint16_t, tsl::ah::power_of_two_growth_policy<4>>,
+ tsl::array_set<CharT, Hash, tsl::ah::str_equal<CharT>, false, KeySizeT,
+ std::uint16_t,
+ tsl::ah::power_of_two_growth_policy<4>>>::type;
+
+ private:
+ /*
+ * The tree is mainly composed of two nodes types: trie_node and hash_node
+ * which both have anode as base class. Each child is either a hash_node or a
+ * trie_node.
+ *
+ * A hash_node is always a leaf node, it doesn't have any child.
+ *
+ * Example:
+ * | ... | a |.. ..................... | f | ... | trie_node_1
+ * \ \
+ * hash_node_1 |array_hash = {"dd"}| |...| a | ... | trie_node_2
+ * /
+ * |array_hash = {"ble", "bric", "lse"}| hash_node_2
+ *
+ *
+ * Each trie_node may also have a value node, which contains a value T, if the
+ * trie_node marks the end of a string value.
+ *
+ * A trie node should at least have one child or a value node. There can't be
+ * a trie node without any child and no value node.
+ */
+
+ using value_node = tsl::detail_htrie_hash::value_node<T>;
+
+ class trie_node;
+ class hash_node;
+
+ // TODO better encapsulate operations modifying the tree.
+ class anode {
+ friend class trie_node;
+
+ public:
+ /*
+ * TODO Avoid the virtual to economize 8 bytes. We could use a custom
+ * deleter in the std::unique_ptr<anode> we use (as we know if an anode is a
+ * trie_node or hash_node).
+ */
+ virtual ~anode() = default;
+
+ bool is_trie_node() const noexcept {
+ return m_node_type == node_type::TRIE_NODE;
+ }
+
+ bool is_hash_node() const noexcept {
+ return m_node_type == node_type::HASH_NODE;
+ }
+
+ trie_node& as_trie_node() noexcept {
+ tsl_ht_assert(is_trie_node());
+ return static_cast<trie_node&>(*this);
+ }
+
+ hash_node& as_hash_node() noexcept {
+ tsl_ht_assert(is_hash_node());
+ return static_cast<hash_node&>(*this);
+ }
+
+ const trie_node& as_trie_node() const noexcept {
+ tsl_ht_assert(is_trie_node());
+ return static_cast<const trie_node&>(*this);
+ }
+
+ const hash_node& as_hash_node() const noexcept {
+ tsl_ht_assert(is_hash_node());
+ return static_cast<const hash_node&>(*this);
+ }
+
+ /**
+ * @see m_child_of_char
+ */
+ CharT child_of_char() const noexcept {
+ tsl_ht_assert(parent() != nullptr);
+ return m_child_of_char;
+ }
+
+ /**
+ * Return nullptr if none.
+ */
+ trie_node* parent() noexcept { return m_parent_node; }
+
+ const trie_node* parent() const noexcept { return m_parent_node; }
+
+ protected:
+ enum class node_type : unsigned char { HASH_NODE, TRIE_NODE };
+
+ anode(node_type node_type_)
+ : m_node_type(node_type_), m_child_of_char(0), m_parent_node(nullptr) {}
+
+ anode(node_type node_type_, CharT child_of_char)
+ : m_node_type(node_type_),
+ m_child_of_char(child_of_char),
+ m_parent_node(nullptr) {}
+
+ protected:
+ node_type m_node_type;
+
+ /**
+ * If the node has a parent, then it's a descendant of some char.
+ *
+ * Example:
+ * | ... | a | b | ... | trie_node_1
+ * \
+ * |...| a | ... | trie_node_2
+ * /
+ * |array_hash| hash_node_1
+ *
+ * trie_node_2 is a child of trie_node_1 through 'b', it will have 'b' as
+ * m_child_of_char. hash_node_1 is a child of trie_node_2 through 'a', it
+ * will have 'a' as m_child_of_char.
+ *
+ * trie_node_1 has no parent, its m_child_of_char is undefined.
+ */
+ CharT m_child_of_char;
+ trie_node* m_parent_node;
+ };
+
+ // Give the position in trie_node::m_children corresponding to the character c
+ static std::size_t as_position(CharT c) noexcept {
+ return static_cast<std::size_t>(
+ static_cast<typename std::make_unsigned<CharT>::type>(c));
+ }
+
+ class trie_node : public anode {
+ public:
+ trie_node()
+ : anode(anode::node_type::TRIE_NODE),
+ m_value_node(nullptr),
+ m_children() {}
+
+ trie_node(const trie_node& other)
+ : anode(anode::node_type::TRIE_NODE, other.m_child_of_char),
+ m_value_node(nullptr),
+ m_children() {
+ if (other.m_value_node != nullptr) {
+ m_value_node = make_unique<value_node>(*other.m_value_node);
+ }
+
+ // TODO avoid recursion
+ for (std::size_t ichild = 0; ichild < other.m_children.size(); ichild++) {
+ if (other.m_children[ichild] != nullptr) {
+ if (other.m_children[ichild]->is_hash_node()) {
+ m_children[ichild] = make_unique<hash_node>(
+ other.m_children[ichild]->as_hash_node());
+ } else {
+ m_children[ichild] = make_unique<trie_node>(
+ other.m_children[ichild]->as_trie_node());
+ }
+
+ m_children[ichild]->m_parent_node = this;
+ }
+ }
+ }
+
+ trie_node(trie_node&& other) = delete;
+ trie_node& operator=(const trie_node& other) = delete;
+ trie_node& operator=(trie_node&& other) = delete;
+
+ /**
+ * Return nullptr if none.
+ */
+ anode* first_child() noexcept {
+ return const_cast<anode*>(
+ static_cast<const trie_node*>(this)->first_child());
+ }
+
+ const anode* first_child() const noexcept {
+ for (std::size_t ichild = 0; ichild < m_children.size(); ichild++) {
+ if (m_children[ichild] != nullptr) {
+ return m_children[ichild].get();
+ }
+ }
+
+ return nullptr;
+ }
+
+ /**
+ * Get the next_child that come after current_child. Return nullptr if no
+ * next child.
+ */
+ anode* next_child(const anode& current_child) noexcept {
+ return const_cast<anode*>(
+ static_cast<const trie_node*>(this)->next_child(current_child));
+ }
+
+ const anode* next_child(const anode& current_child) const noexcept {
+ tsl_ht_assert(current_child.parent() == this);
+
+ for (std::size_t ichild = as_position(current_child.child_of_char()) + 1;
+ ichild < m_children.size(); ichild++) {
+ if (m_children[ichild] != nullptr) {
+ return m_children[ichild].get();
+ }
+ }
+
+ return nullptr;
+ }
+
+ /**
+ * Return the first left-descendant trie node with an m_value_node. If none
+ * return the most left trie node.
+ */
+ trie_node& most_left_descendant_value_trie_node() noexcept {
+ return const_cast<trie_node&>(
+ static_cast<const trie_node*>(this)
+ ->most_left_descendant_value_trie_node());
+ }
+
+ const trie_node& most_left_descendant_value_trie_node() const noexcept {
+ const trie_node* current_node = this;
+ while (true) {
+ if (current_node->m_value_node != nullptr) {
+ return *current_node;
+ }
+
+ const anode* first_child = current_node->first_child();
+ tsl_ht_assert(first_child !=
+ nullptr); // a trie_node must either have a value_node or
+ // at least one child.
+ if (first_child->is_hash_node()) {
+ return *current_node;
+ }
+
+ current_node = &first_child->as_trie_node();
+ }
+ }
+
+ size_type nb_children() const noexcept {
+ return std::count_if(
+ m_children.cbegin(), m_children.cend(),
+ [](const std::unique_ptr<anode>& n) { return n != nullptr; });
+ }
+
+ bool empty() const noexcept {
+ return std::all_of(
+ m_children.cbegin(), m_children.cend(),
+ [](const std::unique_ptr<anode>& n) { return n == nullptr; });
+ }
+
+ std::unique_ptr<anode>& child(CharT for_char) noexcept {
+ return m_children[as_position(for_char)];
+ }
+
+ const std::unique_ptr<anode>& child(CharT for_char) const noexcept {
+ return m_children[as_position(for_char)];
+ }
+
+ typename std::array<std::unique_ptr<anode>, ALPHABET_SIZE>::iterator
+ begin() noexcept {
+ return m_children.begin();
+ }
+
+ typename std::array<std::unique_ptr<anode>, ALPHABET_SIZE>::iterator
+ end() noexcept {
+ return m_children.end();
+ }
+
+ void set_child(CharT for_char, std::unique_ptr<anode> child) noexcept {
+ if (child != nullptr) {
+ child->m_child_of_char = for_char;
+ child->m_parent_node = this;
+ }
+
+ m_children[as_position(for_char)] = std::move(child);
+ }
+
+ std::unique_ptr<value_node>& val_node() noexcept { return m_value_node; }
+
+ const std::unique_ptr<value_node>& val_node() const noexcept {
+ return m_value_node;
+ }
+
+ private:
+ // TODO Avoid storing a value_node when has_value<T>::value is false
+ std::unique_ptr<value_node> m_value_node;
+
+ /**
+ * Each character CharT corresponds to one position in the array. To convert
+ * a character to a position use the as_position method.
+ *
+ * TODO Try to reduce the size of m_children with a hash map, linear/binary
+ * search on array, ...
+ * TODO Store number of non-null values in m_children. Check if we can store
+ * this value in the alignment space as we don't want the node to get bigger
+ * (empty() and nb_children() are rarely used so it is not an important
+ * variable).
+ */
+ std::array<std::unique_ptr<anode>, ALPHABET_SIZE> m_children;
+ };
+
+ class hash_node : public anode {
+ public:
+ hash_node(const Hash& hash, float max_load_factor)
+ : hash_node(HASH_NODE_DEFAULT_INIT_BUCKETS_COUNT, hash,
+ max_load_factor) {}
+
+ hash_node(size_type bucket_count, const Hash& hash, float max_load_factor)
+ : anode(anode::node_type::HASH_NODE), m_array_hash(bucket_count, hash) {
+ m_array_hash.max_load_factor(max_load_factor);
+ }
+
+ hash_node(array_hash_type&& array_hash) noexcept(
+ std::is_nothrow_move_constructible<array_hash_type>::value)
+ : anode(anode::node_type::HASH_NODE),
+ m_array_hash(std::move(array_hash)) {}
+
+ hash_node(const hash_node& other) = default;
+
+ hash_node(hash_node&& other) = delete;
+ hash_node& operator=(const hash_node& other) = delete;
+ hash_node& operator=(hash_node&& other) = delete;
+
+ array_hash_type& array_hash() noexcept { return m_array_hash; }
+
+ const array_hash_type& array_hash() const noexcept { return m_array_hash; }
+
+ private:
+ array_hash_type m_array_hash;
+ };
+
+ public:
+ template <bool IsConst, bool IsPrefixIterator>
+ class htrie_hash_iterator {
+ friend class htrie_hash;
+
+ private:
+ using anode_type =
+ typename std::conditional<IsConst, const anode, anode>::type;
+ using trie_node_type =
+ typename std::conditional<IsConst, const trie_node, trie_node>::type;
+ using hash_node_type =
+ typename std::conditional<IsConst, const hash_node, hash_node>::type;
+
+ using array_hash_iterator_type =
+ typename std::conditional<IsConst,
+ typename array_hash_type::const_iterator,
+ typename array_hash_type::iterator>::type;
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type =
+ typename std::conditional<has_value<T>::value, T, void>::type;
+ using difference_type = std::ptrdiff_t;
+ using reference = typename std::conditional<
+ has_value<T>::value,
+ typename std::conditional<
+ IsConst, typename std::add_lvalue_reference<const T>::type,
+ typename std::add_lvalue_reference<T>::type>::type,
+ void>::type;
+ using pointer = typename std::conditional<
+ has_value<T>::value,
+ typename std::conditional<IsConst, const T*, T*>::type, void>::type;
+
+ private:
+ /**
+ * Start reading from start_hash_node->array_hash().begin().
+ */
+ htrie_hash_iterator(hash_node_type& start_hash_node) noexcept
+ : htrie_hash_iterator(start_hash_node,
+ start_hash_node.array_hash().begin()) {}
+
+ /**
+ * Start reading from iterator begin in start_hash_node->array_hash().
+ */
+ htrie_hash_iterator(hash_node_type& start_hash_node,
+ array_hash_iterator_type begin) noexcept
+ : m_current_trie_node(start_hash_node.parent()),
+ m_current_hash_node(&start_hash_node),
+ m_array_hash_iterator(begin),
+ m_array_hash_end_iterator(start_hash_node.array_hash().end()),
+ m_read_trie_node_value(false) {
+ tsl_ht_assert(!m_current_hash_node->array_hash().empty());
+ }
+
+ /**
+ * Start reading from the value in start_trie_node.
+ * start_trie_node->val_node() should be non-null.
+ */
+ htrie_hash_iterator(trie_node_type& start_trie_node) noexcept
+ : m_current_trie_node(&start_trie_node),
+ m_current_hash_node(nullptr),
+ m_read_trie_node_value(true) {
+ tsl_ht_assert(m_current_trie_node->val_node() != nullptr);
+ }
+
+ template <bool P = IsPrefixIterator,
+ typename std::enable_if<!P>::type* = nullptr>
+ htrie_hash_iterator(trie_node_type* tnode, hash_node_type* hnode,
+ array_hash_iterator_type begin,
+ array_hash_iterator_type end,
+ bool read_trie_node_value) noexcept
+ : m_current_trie_node(tnode),
+ m_current_hash_node(hnode),
+ m_array_hash_iterator(begin),
+ m_array_hash_end_iterator(end),
+ m_read_trie_node_value(read_trie_node_value) {}
+
+ template <bool P = IsPrefixIterator,
+ typename std::enable_if<P>::type* = nullptr>
+ htrie_hash_iterator(trie_node_type* tnode, hash_node_type* hnode,
+ array_hash_iterator_type begin,
+ array_hash_iterator_type end, bool read_trie_node_value,
+ std::basic_string<CharT> prefix_filter) noexcept
+ : m_current_trie_node(tnode),
+ m_current_hash_node(hnode),
+ m_array_hash_iterator(begin),
+ m_array_hash_end_iterator(end),
+ m_read_trie_node_value(read_trie_node_value),
+ m_prefix_filter(std::move(prefix_filter)) {}
+
+ public:
+ htrie_hash_iterator() noexcept {}
+
+ // Copy constructor from iterator to const_iterator.
+ template <bool TIsConst = IsConst,
+ bool TIsPrefixIterator = IsPrefixIterator,
+ typename std::enable_if<TIsConst && !TIsPrefixIterator>::type* =
+ nullptr>
+ htrie_hash_iterator(
+ const htrie_hash_iterator<!TIsConst, TIsPrefixIterator>& other) noexcept
+ : m_current_trie_node(other.m_current_trie_node),
+ m_current_hash_node(other.m_current_hash_node),
+ m_array_hash_iterator(other.m_array_hash_iterator),
+ m_array_hash_end_iterator(other.m_array_hash_end_iterator),
+ m_read_trie_node_value(other.m_read_trie_node_value) {}
+
+ // Copy constructor from iterator to const_iterator.
+ template <
+ bool TIsConst = IsConst, bool TIsPrefixIterator = IsPrefixIterator,
+ typename std::enable_if<TIsConst && TIsPrefixIterator>::type* = nullptr>
+ htrie_hash_iterator(
+ const htrie_hash_iterator<!TIsConst, TIsPrefixIterator>& other) noexcept
+ : m_current_trie_node(other.m_current_trie_node),
+ m_current_hash_node(other.m_current_hash_node),
+ m_array_hash_iterator(other.m_array_hash_iterator),
+ m_array_hash_end_iterator(other.m_array_hash_end_iterator),
+ m_read_trie_node_value(other.m_read_trie_node_value),
+ m_prefix_filter(other.m_prefix_filter) {}
+
+ htrie_hash_iterator(const htrie_hash_iterator& other) = default;
+ htrie_hash_iterator(htrie_hash_iterator&& other) = default;
+ htrie_hash_iterator& operator=(const htrie_hash_iterator& other) = default;
+ htrie_hash_iterator& operator=(htrie_hash_iterator&& other) = default;
+
+ void key(std::basic_string<CharT>& key_buffer_out) const {
+ key_buffer_out.clear();
+
+ trie_node_type* tnode = m_current_trie_node;
+ while (tnode != nullptr && tnode->parent() != nullptr) {
+ key_buffer_out.push_back(tnode->child_of_char());
+ tnode = tnode->parent();
+ }
+
+ std::reverse(key_buffer_out.begin(), key_buffer_out.end());
+
+ if (!m_read_trie_node_value) {
+ tsl_ht_assert(m_current_hash_node != nullptr);
+ if (m_current_hash_node->parent() != nullptr) {
+ key_buffer_out.push_back(m_current_hash_node->child_of_char());
+ }
+
+ key_buffer_out.append(m_array_hash_iterator.key(),
+ m_array_hash_iterator.key_size());
+ }
+ }
+
+ std::basic_string<CharT> key() const {
+ std::basic_string<CharT> key_buffer;
+ key(key_buffer);
+
+ return key_buffer;
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ reference value() const {
+ if (this->m_read_trie_node_value) {
+ tsl_ht_assert(this->m_current_trie_node != nullptr);
+ tsl_ht_assert(this->m_current_trie_node->val_node() != nullptr);
+
+ return this->m_current_trie_node->val_node()->m_value;
+ } else {
+ return this->m_array_hash_iterator.value();
+ }
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ reference operator*() const {
+ return value();
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ pointer operator->() const {
+ return std::addressof(value());
+ }
+
+ htrie_hash_iterator& operator++() {
+ if (m_read_trie_node_value) {
+ tsl_ht_assert(m_current_trie_node != nullptr);
+
+ m_read_trie_node_value = false;
+
+ anode_type* child = m_current_trie_node->first_child();
+ if (child != nullptr) {
+ set_most_left_descendant_as_next_node(*child);
+ } else if (m_current_trie_node->parent() != nullptr) {
+ trie_node_type* current_node_child = m_current_trie_node;
+ m_current_trie_node = m_current_trie_node->parent();
+
+ set_next_node_ascending(*current_node_child);
+ } else {
+ set_as_end_iterator();
+ }
+ } else {
+ ++m_array_hash_iterator;
+ if (m_array_hash_iterator != m_array_hash_end_iterator) {
+ filter_prefix();
+ }
+ // End of the road, set the iterator as an end node.
+ else if (m_current_trie_node == nullptr) {
+ set_as_end_iterator();
+ } else {
+ tsl_ht_assert(m_current_hash_node != nullptr);
+ set_next_node_ascending(*m_current_hash_node);
+ }
+ }
+
+ return *this;
+ }
+
+ htrie_hash_iterator operator++(int) {
+ htrie_hash_iterator tmp(*this);
+ ++*this;
+
+ return tmp;
+ }
+
+ friend bool operator==(const htrie_hash_iterator& lhs,
+ const htrie_hash_iterator& rhs) {
+ if (lhs.m_current_trie_node != rhs.m_current_trie_node ||
+ lhs.m_read_trie_node_value != rhs.m_read_trie_node_value) {
+ return false;
+ } else if (lhs.m_read_trie_node_value) {
+ return true;
+ } else {
+ if (lhs.m_current_hash_node != rhs.m_current_hash_node) {
+ return false;
+ } else if (lhs.m_current_hash_node == nullptr) {
+ return true;
+ } else {
+ return lhs.m_array_hash_iterator == rhs.m_array_hash_iterator &&
+ lhs.m_array_hash_end_iterator == rhs.m_array_hash_end_iterator;
+ }
+ }
+ }
+
+ friend bool operator!=(const htrie_hash_iterator& lhs,
+ const htrie_hash_iterator& rhs) {
+ return !(lhs == rhs);
+ }
+
+ private:
+ void hash_node_prefix(std::basic_string<CharT>& key_buffer_out) const {
+ tsl_ht_assert(!m_read_trie_node_value);
+ key_buffer_out.clear();
+
+ trie_node_type* tnode = m_current_trie_node;
+ while (tnode != nullptr && tnode->parent() != nullptr) {
+ key_buffer_out.push_back(tnode->child_of_char());
+ tnode = tnode->parent();
+ }
+
+ std::reverse(key_buffer_out.begin(), key_buffer_out.end());
+
+ tsl_ht_assert(m_current_hash_node != nullptr);
+ if (m_current_hash_node->parent() != nullptr) {
+ key_buffer_out.push_back(m_current_hash_node->child_of_char());
+ }
+ }
+
+ template <bool P = IsPrefixIterator,
+ typename std::enable_if<!P>::type* = nullptr>
+ void filter_prefix() {}
+
+ template <bool P = IsPrefixIterator,
+ typename std::enable_if<P>::type* = nullptr>
+ void filter_prefix() {
+ tsl_ht_assert(m_array_hash_iterator != m_array_hash_end_iterator);
+ tsl_ht_assert(!m_read_trie_node_value && m_current_hash_node != nullptr);
+
+ if (m_prefix_filter.empty()) {
+ return;
+ }
+
+ while ((m_prefix_filter.size() > m_array_hash_iterator.key_size() ||
+ m_prefix_filter.compare(0, m_prefix_filter.size(),
+ m_array_hash_iterator.key(),
+ m_prefix_filter.size()) != 0)) {
+ ++m_array_hash_iterator;
+ if (m_array_hash_iterator == m_array_hash_end_iterator) {
+ if (m_current_trie_node == nullptr) {
+ set_as_end_iterator();
+ } else {
+ tsl_ht_assert(m_current_hash_node != nullptr);
+ set_next_node_ascending(*m_current_hash_node);
+ }
+
+ return;
+ }
+ }
+ }
+
+ /**
+ * Go back up in the tree to get the current_trie_node_child sibling.
+ * If none, try to go back up more in the tree to check the siblings of the
+ * ancestors.
+ */
+ void set_next_node_ascending(anode_type& current_trie_node_child) {
+ tsl_ht_assert(m_current_trie_node != nullptr);
+ tsl_ht_assert(current_trie_node_child.parent() == m_current_trie_node);
+
+ anode_type* next_node =
+ m_current_trie_node->next_child(current_trie_node_child);
+ while (next_node == nullptr && m_current_trie_node->parent() != nullptr) {
+ anode_type* current_child = m_current_trie_node;
+ m_current_trie_node = m_current_trie_node->parent();
+ next_node = m_current_trie_node->next_child(*current_child);
+ }
+
+ // End of the road, set the iterator as an end node.
+ if (next_node == nullptr) {
+ set_as_end_iterator();
+ } else {
+ set_most_left_descendant_as_next_node(*next_node);
+ }
+ }
+
+ void set_most_left_descendant_as_next_node(anode_type& search_start) {
+ if (search_start.is_hash_node()) {
+ set_current_hash_node(search_start.as_hash_node());
+ } else {
+ m_current_trie_node =
+ &search_start.as_trie_node().most_left_descendant_value_trie_node();
+ if (m_current_trie_node->val_node() != nullptr) {
+ m_read_trie_node_value = true;
+ } else {
+ anode_type* first_child = m_current_trie_node->first_child();
+ // a trie_node must either have a value_node or at least one child.
+ tsl_ht_assert(first_child != nullptr);
+
+ set_current_hash_node(first_child->as_hash_node());
+ }
+ }
+ }
+
+ void set_current_hash_node(hash_node_type& hnode) {
+ tsl_ht_assert(!hnode.array_hash().empty());
+
+ m_current_hash_node = &hnode;
+ m_array_hash_iterator = m_current_hash_node->array_hash().begin();
+ m_array_hash_end_iterator = m_current_hash_node->array_hash().end();
+ }
+
+ void set_as_end_iterator() {
+ m_current_trie_node = nullptr;
+ m_current_hash_node = nullptr;
+ m_read_trie_node_value = false;
+ }
+
+ void skip_hash_node() {
+ tsl_ht_assert(!m_read_trie_node_value && m_current_hash_node != nullptr);
+ if (m_current_trie_node == nullptr) {
+ set_as_end_iterator();
+ } else {
+ tsl_ht_assert(m_current_hash_node != nullptr);
+ set_next_node_ascending(*m_current_hash_node);
+ }
+ }
+
+ private:
+ trie_node_type* m_current_trie_node;
+ hash_node_type* m_current_hash_node;
+
+ array_hash_iterator_type m_array_hash_iterator;
+ array_hash_iterator_type m_array_hash_end_iterator;
+
+ bool m_read_trie_node_value;
+ // TODO can't have void if !IsPrefixIterator, use inheritance
+ typename std::conditional<IsPrefixIterator, std::basic_string<CharT>,
+ bool>::type m_prefix_filter;
+ };
+
+ public:
+ htrie_hash(const Hash& hash, float max_load_factor, size_type burst_threshold)
+ : m_root(nullptr),
+ m_nb_elements(0),
+ m_hash(hash),
+ m_max_load_factor(max_load_factor) {
+ this->burst_threshold(burst_threshold);
+ }
+
+ htrie_hash(const htrie_hash& other)
+ : m_root(nullptr),
+ m_nb_elements(other.m_nb_elements),
+ m_hash(other.m_hash),
+ m_max_load_factor(other.m_max_load_factor),
+ m_burst_threshold(other.m_burst_threshold) {
+ if (other.m_root != nullptr) {
+ if (other.m_root->is_hash_node()) {
+ m_root = make_unique<hash_node>(other.m_root->as_hash_node());
+ } else {
+ m_root = make_unique<trie_node>(other.m_root->as_trie_node());
+ }
+ }
+ }
+
+ htrie_hash(htrie_hash&& other) noexcept(
+ std::is_nothrow_move_constructible<Hash>::value)
+ : m_root(std::move(other.m_root)),
+ m_nb_elements(other.m_nb_elements),
+ m_hash(std::move(other.m_hash)),
+ m_max_load_factor(other.m_max_load_factor),
+ m_burst_threshold(other.m_burst_threshold) {
+ other.clear();
+ }
+
+ htrie_hash& operator=(const htrie_hash& other) {
+ if (&other != this) {
+ std::unique_ptr<anode> new_root = nullptr;
+ if (other.m_root != nullptr) {
+ if (other.m_root->is_hash_node()) {
+ new_root = make_unique<hash_node>(other.m_root->as_hash_node());
+ } else {
+ new_root = make_unique<trie_node>(other.m_root->as_trie_node());
+ }
+ }
+
+ m_hash = other.m_hash;
+ m_root = std::move(new_root);
+ m_nb_elements = other.m_nb_elements;
+ m_max_load_factor = other.m_max_load_factor;
+ m_burst_threshold = other.m_burst_threshold;
+ }
+
+ return *this;
+ }
+
+ htrie_hash& operator=(htrie_hash&& other) {
+ other.swap(*this);
+ other.clear();
+
+ return *this;
+ }
+
+ /*
+ * Iterators
+ */
+ iterator begin() noexcept { return mutable_iterator(cbegin()); }
+
+ const_iterator begin() const noexcept { return cbegin(); }
+
+ const_iterator cbegin() const noexcept {
+ if (empty()) {
+ return cend();
+ }
+
+ return cbegin<const_iterator>(*m_root);
+ }
+
+ iterator end() noexcept {
+ iterator it;
+ it.set_as_end_iterator();
+
+ return it;
+ }
+
+ const_iterator end() const noexcept { return cend(); }
+
+ const_iterator cend() const noexcept {
+ const_iterator it;
+ it.set_as_end_iterator();
+
+ return it;
+ }
+
+ /*
+ * Capacity
+ */
+ bool empty() const noexcept { return m_nb_elements == 0; }
+
+ size_type size() const noexcept { return m_nb_elements; }
+
+ size_type max_size() const noexcept {
+ return std::numeric_limits<size_type>::max();
+ }
+
+ size_type max_key_size() const noexcept {
+ return array_hash_type::MAX_KEY_SIZE;
+ }
+
+ void shrink_to_fit() {
+ auto first = begin();
+ auto last = end();
+
+ while (first != last) {
+ if (first.m_read_trie_node_value) {
+ ++first;
+ } else {
+ /*
+ * shrink_to_fit on array_hash will invalidate the iterators of
+ * array_hash. Save pointer to array_hash, skip the array_hash_node and
+ * then call shrink_to_fit on the saved pointer.
+ */
+ hash_node* hnode = first.m_current_hash_node;
+ first.skip_hash_node();
+
+ tsl_ht_assert(hnode != nullptr);
+ hnode->array_hash().shrink_to_fit();
+ }
+ }
+ }
+
+ /*
+ * Modifiers
+ */
+ void clear() noexcept {
+ m_root.reset(nullptr);
+ m_nb_elements = 0;
+ }
+
+ template <class... ValueArgs>
+ std::pair<iterator, bool> insert(const CharT* key, size_type key_size,
+ ValueArgs&&... value_args) {
+ if (key_size > max_key_size()) {
+ throw std::length_error("Key is too long.");
+ }
+
+ if (m_root == nullptr) {
+ m_root = make_unique<hash_node>(m_hash, m_max_load_factor);
+ }
+
+ return insert_impl(*m_root, key, key_size,
+ std::forward<ValueArgs>(value_args)...);
+ }
+
+ iterator erase(const_iterator pos) { return erase(mutable_iterator(pos)); }
+
+ iterator erase(const_iterator first, const_iterator last) {
+ // TODO Optimize, could avoid the call to std::distance
+ const std::size_t nb_to_erase = std::size_t(std::distance(first, last));
+ auto to_delete = mutable_iterator(first);
+ for (std::size_t i = 0; i < nb_to_erase; i++) {
+ to_delete = erase(to_delete);
+ }
+
+ return to_delete;
+ }
+
+ size_type erase(const CharT* key, size_type key_size) {
+ auto it = find(key, key_size);
+ if (it != end()) {
+ erase(it);
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ size_type erase_prefix(const CharT* prefix, size_type prefix_size) {
+ if (m_root == nullptr) {
+ return 0;
+ }
+
+ anode* current_node = m_root.get();
+ for (size_type iprefix = 0; iprefix < prefix_size; iprefix++) {
+ if (current_node->is_trie_node()) {
+ trie_node* tnode = &current_node->as_trie_node();
+
+ if (tnode->child(prefix[iprefix]) == nullptr) {
+ return 0;
+ } else {
+ current_node = tnode->child(prefix[iprefix]).get();
+ }
+ } else {
+ hash_node& hnode = current_node->as_hash_node();
+ return erase_prefix_hash_node(hnode, prefix + iprefix,
+ prefix_size - iprefix);
+ }
+ }
+
+ if (current_node->is_trie_node()) {
+ trie_node* parent = current_node->parent();
+
+ if (parent != nullptr) {
+ const size_type nb_erased =
+ size_descendants(current_node->as_trie_node());
+
+ parent->set_child(current_node->child_of_char(), nullptr);
+ m_nb_elements -= nb_erased;
+
+ if (parent->empty()) {
+ clear_empty_nodes(*parent);
+ }
+
+ return nb_erased;
+ } else {
+ const size_type nb_erased = m_nb_elements;
+ m_root.reset(nullptr);
+ m_nb_elements = 0;
+
+ return nb_erased;
+ }
+ } else {
+ const size_type nb_erased =
+ current_node->as_hash_node().array_hash().size();
+
+ current_node->as_hash_node().array_hash().clear();
+ m_nb_elements -= nb_erased;
+
+ clear_empty_nodes(current_node->as_hash_node());
+
+ return nb_erased;
+ }
+ }
+
+ void swap(htrie_hash& other) {
+ using std::swap;
+
+ swap(m_hash, other.m_hash);
+ swap(m_root, other.m_root);
+ swap(m_nb_elements, other.m_nb_elements);
+ swap(m_max_load_factor, other.m_max_load_factor);
+ swap(m_burst_threshold, other.m_burst_threshold);
+ }
+
+ /*
+ * Lookup
+ */
+ template <class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ U& at(const CharT* key, size_type key_size) {
+ return const_cast<U&>(
+ static_cast<const htrie_hash*>(this)->at(key, key_size));
+ }
+
+ template <class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ const U& at(const CharT* key, size_type key_size) const {
+ auto it_find = find(key, key_size);
+ if (it_find != cend()) {
+ return it_find.value();
+ } else {
+ throw std::out_of_range("Couldn't find key.");
+ }
+ }
+
+ // TODO optimize
+ template <class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ U& access_operator(const CharT* key, size_type key_size) {
+ auto it_find = find(key, key_size);
+ if (it_find != cend()) {
+ return it_find.value();
+ } else {
+ return insert(key, key_size, U{}).first.value();
+ }
+ }
+
+ size_type count(const CharT* key, size_type key_size) const {
+ if (find(key, key_size) != cend()) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ iterator find(const CharT* key, size_type key_size) {
+ if (m_root == nullptr) {
+ return end();
+ }
+
+ return find_impl(*m_root, key, key_size);
+ }
+
+ const_iterator find(const CharT* key, size_type key_size) const {
+ if (m_root == nullptr) {
+ return cend();
+ }
+
+ return find_impl(*m_root, key, key_size);
+ }
+
+ std::pair<iterator, iterator> equal_range(const CharT* key,
+ size_type key_size) {
+ iterator it = find(key, key_size);
+ return std::make_pair(it, (it == end()) ? it : std::next(it));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key, size_type key_size) const {
+ const_iterator it = find(key, key_size);
+ return std::make_pair(it, (it == cend()) ? it : std::next(it));
+ }
+
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const CharT* prefix, size_type prefix_size) {
+ if (m_root == nullptr) {
+ return std::make_pair(prefix_end(), prefix_end());
+ }
+
+ return equal_prefix_range_impl(*m_root, prefix, prefix_size);
+ }
+
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const CharT* prefix, size_type prefix_size) const {
+ if (m_root == nullptr) {
+ return std::make_pair(prefix_cend(), prefix_cend());
+ }
+
+ return equal_prefix_range_impl(*m_root, prefix, prefix_size);
+ }
+
+ iterator longest_prefix(const CharT* key, size_type key_size) {
+ if (m_root == nullptr) {
+ return end();
+ }
+
+ return longest_prefix_impl(*m_root, key, key_size);
+ }
+
+ const_iterator longest_prefix(const CharT* key, size_type key_size) const {
+ if (m_root == nullptr) {
+ return cend();
+ }
+
+ return longest_prefix_impl(*m_root, key, key_size);
+ }
+
+ /*
+ * Hash policy
+ */
+ float max_load_factor() const { return m_max_load_factor; }
+
+ void max_load_factor(float ml) { m_max_load_factor = ml; }
+
+ /*
+ * Burst policy
+ */
+ size_type burst_threshold() const { return m_burst_threshold; }
+
+ void burst_threshold(size_type threshold) {
+ const size_type min_burst_threshold = MIN_BURST_THRESHOLD;
+ m_burst_threshold = std::max(min_burst_threshold, threshold);
+ }
+
+ /*
+ * Observers
+ */
+ hasher hash_function() const { return m_hash; }
+
+ /*
+ * Other
+ */
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ serialize_impl(serializer);
+ }
+
+ template <class Deserializer>
+ void deserialize(Deserializer& deserializer, bool hash_compatible) {
+ deserialize_impl(deserializer, hash_compatible);
+ }
+
+ private:
+ /**
+ * Get the begin iterator by searching for the most left descendant node
+ * starting at search_start_node.
+ */
+ template <typename Iterator>
+ Iterator cbegin(const anode& search_start_node) const noexcept {
+ if (search_start_node.is_hash_node()) {
+ return Iterator(search_start_node.as_hash_node());
+ }
+
+ const trie_node& tnode =
+ search_start_node.as_trie_node().most_left_descendant_value_trie_node();
+ if (tnode.val_node() != nullptr) {
+ return Iterator(tnode);
+ } else {
+ const anode* first_child = tnode.first_child();
+ tsl_ht_assert(first_child != nullptr);
+
+ return Iterator(first_child->as_hash_node());
+ }
+ }
+
+ /**
+ * Get an iterator to the node that come just after the last descendant of
+ * search_start_node.
+ */
+ template <typename Iterator>
+ Iterator cend(const anode& search_start_node) const noexcept {
+ if (search_start_node.parent() == nullptr) {
+ Iterator it;
+ it.set_as_end_iterator();
+
+ return it;
+ }
+
+ const trie_node* current_trie_node = search_start_node.parent();
+ const anode* next_node = current_trie_node->next_child(search_start_node);
+
+ while (next_node == nullptr && current_trie_node->parent() != nullptr) {
+ const anode* current_child = current_trie_node;
+ current_trie_node = current_trie_node->parent();
+ next_node = current_trie_node->next_child(*current_child);
+ }
+
+ if (next_node == nullptr) {
+ Iterator it;
+ it.set_as_end_iterator();
+
+ return it;
+ } else {
+ return cbegin<Iterator>(*next_node);
+ }
+ }
+
+ prefix_iterator prefix_end() noexcept {
+ prefix_iterator it;
+ it.set_as_end_iterator();
+
+ return it;
+ }
+
+ const_prefix_iterator prefix_cend() const noexcept {
+ const_prefix_iterator it;
+ it.set_as_end_iterator();
+
+ return it;
+ }
+
+ size_type size_descendants(const anode& start_node) const {
+ auto first = cbegin<const_iterator>(start_node);
+ auto last = cend<const_iterator>(start_node);
+
+ size_type nb_elements = 0;
+ while (first != last) {
+ if (first.m_read_trie_node_value) {
+ nb_elements++;
+ ++first;
+ } else {
+ nb_elements += first.m_current_hash_node->array_hash().size();
+ first.skip_hash_node();
+ }
+ }
+
+ return nb_elements;
+ }
+
+ template <class... ValueArgs>
+ std::pair<iterator, bool> insert_impl(anode& search_start_node,
+ const CharT* key, size_type key_size,
+ ValueArgs&&... value_args) {
+ anode* current_node = &search_start_node;
+
+ for (size_type ikey = 0; ikey < key_size; ikey++) {
+ if (current_node->is_trie_node()) {
+ trie_node& tnode = current_node->as_trie_node();
+
+ if (tnode.child(key[ikey]) != nullptr) {
+ current_node = tnode.child(key[ikey]).get();
+ } else {
+ auto hnode = make_unique<hash_node>(m_hash, m_max_load_factor);
+ auto insert_it = hnode->array_hash().emplace_ks(
+ key + ikey + 1, key_size - ikey - 1,
+ std::forward<ValueArgs>(value_args)...);
+
+ tnode.set_child(key[ikey], std::move(hnode));
+ m_nb_elements++;
+
+ return std::make_pair(
+ iterator(tnode.child(key[ikey])->as_hash_node(), insert_it.first),
+ true);
+ }
+ } else {
+ return insert_in_hash_node(current_node->as_hash_node(), key + ikey,
+ key_size - ikey,
+ std::forward<ValueArgs>(value_args)...);
+ }
+ }
+
+ if (current_node->is_trie_node()) {
+ trie_node& tnode = current_node->as_trie_node();
+ if (tnode.val_node() != nullptr) {
+ return std::make_pair(iterator(tnode), false);
+ } else {
+ tnode.val_node() =
+ make_unique<value_node>(std::forward<ValueArgs>(value_args)...);
+ m_nb_elements++;
+
+ return std::make_pair(iterator(tnode), true);
+ }
+ } else {
+ return insert_in_hash_node(current_node->as_hash_node(), "", 0,
+ std::forward<ValueArgs>(value_args)...);
+ }
+ }
+
+ template <class... ValueArgs>
+ std::pair<iterator, bool> insert_in_hash_node(hash_node& hnode,
+ const CharT* key,
+ size_type key_size,
+ ValueArgs&&... value_args) {
+ if (need_burst(hnode)) {
+ std::unique_ptr<trie_node> new_node = burst(hnode);
+ if (hnode.parent() == nullptr) {
+ tsl_ht_assert(m_root.get() == &hnode);
+
+ m_root = std::move(new_node);
+ return insert_impl(*m_root, key, key_size,
+ std::forward<ValueArgs>(value_args)...);
+ } else {
+ trie_node* parent = hnode.parent();
+ const CharT child_of_char = hnode.child_of_char();
+
+ parent->set_child(child_of_char, std::move(new_node));
+
+ return insert_impl(*parent->child(child_of_char), key, key_size,
+ std::forward<ValueArgs>(value_args)...);
+ }
+ } else {
+ auto it_insert = hnode.array_hash().emplace_ks(
+ key, key_size, std::forward<ValueArgs>(value_args)...);
+ if (it_insert.second) {
+ m_nb_elements++;
+ }
+
+ return std::make_pair(iterator(hnode, it_insert.first), it_insert.second);
+ }
+ }
+
+ iterator erase(iterator pos) {
+ iterator next_pos = std::next(pos);
+
+ if (pos.m_read_trie_node_value) {
+ tsl_ht_assert(pos.m_current_trie_node != nullptr &&
+ pos.m_current_trie_node->val_node() != nullptr);
+
+ pos.m_current_trie_node->val_node().reset(nullptr);
+ m_nb_elements--;
+
+ if (pos.m_current_trie_node->empty()) {
+ clear_empty_nodes(*pos.m_current_trie_node);
+ }
+
+ return next_pos;
+ } else {
+ tsl_ht_assert(pos.m_current_hash_node != nullptr);
+ auto next_array_hash_it = pos.m_current_hash_node->array_hash().erase(
+ pos.m_array_hash_iterator);
+ m_nb_elements--;
+
+ if (next_array_hash_it != pos.m_current_hash_node->array_hash().end()) {
+ // The erase on array_hash invalidated the next_pos iterator, return the
+ // right one.
+ return iterator(*pos.m_current_hash_node, next_array_hash_it);
+ } else {
+ if (pos.m_current_hash_node->array_hash().empty()) {
+ clear_empty_nodes(*pos.m_current_hash_node);
+ }
+
+ return next_pos;
+ }
+ }
+ }
+
+ /**
+ * Clear all the empty nodes from the tree starting from empty_node (empty for
+ * a hash_node means that the array hash is empty, for a trie_node it means
+ * the node doesn't have any child or value_node associated to it).
+ */
+ void clear_empty_nodes(anode& empty_node) noexcept {
+ tsl_ht_assert(!empty_node.is_trie_node() ||
+ (empty_node.as_trie_node().empty() &&
+ empty_node.as_trie_node().val_node() == nullptr));
+ tsl_ht_assert(!empty_node.is_hash_node() ||
+ empty_node.as_hash_node().array_hash().empty());
+
+ trie_node* parent = empty_node.parent();
+ if (parent == nullptr) {
+ tsl_ht_assert(m_root.get() == &empty_node);
+ tsl_ht_assert(m_nb_elements == 0);
+ m_root.reset(nullptr);
+ } else if (parent->val_node() != nullptr || parent->nb_children() > 1) {
+ parent->child(empty_node.child_of_char()).reset(nullptr);
+ } else if (parent->parent() == nullptr) {
+ tsl_ht_assert(m_root.get() == empty_node.parent());
+ tsl_ht_assert(m_nb_elements == 0);
+ m_root.reset(nullptr);
+ } else {
+ /**
+ * Parent is empty if we remove its empty_node child.
+ * Put empty_node as new child of the grand parent instead of parent (move
+ * hnode up, and delete the parent). And recurse.
+ *
+ * We can't just set grand_parent->child(parent->child_of_char()) to
+ * nullptr as the grand_parent may also become empty. We don't want empty
+ * trie_node with no value_node in the tree.
+ */
+ trie_node* grand_parent = parent->parent();
+ grand_parent->set_child(
+ parent->child_of_char(),
+ std::move(parent->child(empty_node.child_of_char())));
+
+ clear_empty_nodes(empty_node);
+ }
+ }
+
+ iterator find_impl(const anode& search_start_node, const CharT* key,
+ size_type key_size) {
+ return mutable_iterator(static_cast<const htrie_hash*>(this)->find_impl(
+ search_start_node, key, key_size));
+ }
+
+ const_iterator find_impl(const anode& search_start_node, const CharT* key,
+ size_type key_size) const {
+ const anode* current_node = &search_start_node;
+
+ for (size_type ikey = 0; ikey < key_size; ikey++) {
+ if (current_node->is_trie_node()) {
+ const trie_node* tnode = &current_node->as_trie_node();
+
+ if (tnode->child(key[ikey]) == nullptr) {
+ return cend();
+ } else {
+ current_node = tnode->child(key[ikey]).get();
+ }
+ } else {
+ return find_in_hash_node(current_node->as_hash_node(), key + ikey,
+ key_size - ikey);
+ }
+ }
+
+ if (current_node->is_trie_node()) {
+ const trie_node& tnode = current_node->as_trie_node();
+ return (tnode.val_node() != nullptr) ? const_iterator(tnode) : cend();
+ } else {
+ return find_in_hash_node(current_node->as_hash_node(), "", 0);
+ }
+ }
+
+ const_iterator find_in_hash_node(const hash_node& hnode, const CharT* key,
+ size_type key_size) const {
+ auto it = hnode.array_hash().find_ks(key, key_size);
+ if (it != hnode.array_hash().end()) {
+ return const_iterator(hnode, it);
+ } else {
+ return cend();
+ }
+ }
+
+ iterator longest_prefix_impl(const anode& search_start_node,
+ const CharT* value, size_type value_size) {
+ return mutable_iterator(
+ static_cast<const htrie_hash*>(this)->longest_prefix_impl(
+ search_start_node, value, value_size));
+ }
+
+ const_iterator longest_prefix_impl(const anode& search_start_node,
+ const CharT* value,
+ size_type value_size) const {
+ const anode* current_node = &search_start_node;
+ const_iterator longest_found_prefix = cend();
+
+ for (size_type ivalue = 0; ivalue < value_size; ivalue++) {
+ if (current_node->is_trie_node()) {
+ const trie_node& tnode = current_node->as_trie_node();
+
+ if (tnode.val_node() != nullptr) {
+ longest_found_prefix = const_iterator(tnode);
+ }
+
+ if (tnode.child(value[ivalue]) == nullptr) {
+ return longest_found_prefix;
+ } else {
+ current_node = tnode.child(value[ivalue]).get();
+ }
+ } else {
+ const hash_node& hnode = current_node->as_hash_node();
+
+ /**
+ * Test the presence in the hash node of each substring from the
+ * remaining [ivalue, value_size) string starting from the longest.
+ * Also test the empty string.
+ */
+ for (std::size_t i = ivalue; i <= value_size; i++) {
+ auto it =
+ hnode.array_hash().find_ks(value + ivalue, (value_size - i));
+ if (it != hnode.array_hash().end()) {
+ return const_iterator(hnode, it);
+ }
+ }
+
+ return longest_found_prefix;
+ }
+ }
+
+ if (current_node->is_trie_node()) {
+ const trie_node& tnode = current_node->as_trie_node();
+
+ if (tnode.val_node() != nullptr) {
+ longest_found_prefix = const_iterator(tnode);
+ }
+ } else {
+ const hash_node& hnode = current_node->as_hash_node();
+
+ auto it = hnode.array_hash().find_ks("", 0);
+ if (it != hnode.array_hash().end()) {
+ longest_found_prefix = const_iterator(hnode, it);
+ }
+ }
+
+ return longest_found_prefix;
+ }
+
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range_impl(
+ anode& search_start_node, const CharT* prefix, size_type prefix_size) {
+ auto range = static_cast<const htrie_hash*>(this)->equal_prefix_range_impl(
+ search_start_node, prefix, prefix_size);
+ return std::make_pair(mutable_iterator(range.first),
+ mutable_iterator(range.second));
+ }
+
+ std::pair<const_prefix_iterator, const_prefix_iterator>
+ equal_prefix_range_impl(const anode& search_start_node, const CharT* prefix,
+ size_type prefix_size) const {
+ const anode* current_node = &search_start_node;
+
+ for (size_type iprefix = 0; iprefix < prefix_size; iprefix++) {
+ if (current_node->is_trie_node()) {
+ const trie_node* tnode = &current_node->as_trie_node();
+
+ if (tnode->child(prefix[iprefix]) == nullptr) {
+ return std::make_pair(prefix_cend(), prefix_cend());
+ } else {
+ current_node = tnode->child(prefix[iprefix]).get();
+ }
+ } else {
+ const hash_node& hnode = current_node->as_hash_node();
+ const_prefix_iterator begin(
+ hnode.parent(), &hnode, hnode.array_hash().begin(),
+ hnode.array_hash().end(), false,
+ std::basic_string<CharT>(prefix + iprefix, prefix_size - iprefix));
+ begin.filter_prefix();
+
+ const_prefix_iterator end = cend<const_prefix_iterator>(*current_node);
+
+ return std::make_pair(begin, end);
+ }
+ }
+
+ const_prefix_iterator begin = cbegin<const_prefix_iterator>(*current_node);
+ const_prefix_iterator end = cend<const_prefix_iterator>(*current_node);
+
+ return std::make_pair(begin, end);
+ }
+
+ size_type erase_prefix_hash_node(hash_node& hnode, const CharT* prefix,
+ size_type prefix_size) {
+ size_type nb_erased = 0;
+
+ auto it = hnode.array_hash().begin();
+ while (it != hnode.array_hash().end()) {
+ if (it.key_size() >= prefix_size &&
+ std::memcmp(prefix, it.key(), prefix_size * sizeof(CharT)) == 0) {
+ it = hnode.array_hash().erase(it);
+ ++nb_erased;
+ --m_nb_elements;
+ } else {
+ ++it;
+ }
+ }
+
+ return nb_erased;
+ }
+
+ /*
+ * Burst
+ */
+ bool need_burst(hash_node& node) const {
+ return node.array_hash().size() >= m_burst_threshold;
+ }
+
+ /**
+ * Burst the node and use the copy constructor instead of move constructor for
+ * the values. Also use this method for trivial value types like int, int*,
+ * ... as it requires less book-keeping (thus faster) than the burst using
+ * move constructors.
+ */
+ template <class U = T,
+ typename std::enable_if<
+ has_value<U>::value && std::is_copy_constructible<U>::value &&
+ (!std::is_nothrow_move_constructible<U>::value ||
+ !std::is_nothrow_move_assignable<U>::value ||
+ std::is_arithmetic<U>::value ||
+ std::is_pointer<U>::value)>::type* = nullptr>
+ std::unique_ptr<trie_node> burst(hash_node& node) {
+ const std::array<size_type, ALPHABET_SIZE> first_char_count =
+ get_first_char_count(node.array_hash().cbegin(),
+ node.array_hash().cend());
+
+ auto new_node = make_unique<trie_node>();
+ for (auto it = node.array_hash().cbegin(); it != node.array_hash().cend();
+ ++it) {
+ if (it.key_size() == 0) {
+ new_node->val_node() = make_unique<value_node>(it.value());
+ } else {
+ hash_node& hnode =
+ get_hash_node_for_char(first_char_count, *new_node, it.key()[0]);
+ hnode.array_hash().insert_ks(it.key() + 1, it.key_size() - 1,
+ it.value());
+ }
+ }
+
+ tsl_ht_assert(new_node->val_node() != nullptr || !new_node->empty());
+ return new_node;
+ }
+
+ /**
+ * Burst the node and use the move constructor and move assign operator if
+ * they don't throw.
+ */
+ template <class U = T, typename std::enable_if<
+ has_value<U>::value &&
+ std::is_nothrow_move_constructible<U>::value &&
+ std::is_nothrow_move_assignable<U>::value &&
+ !std::is_arithmetic<U>::value &&
+ !std::is_pointer<U>::value>::type* = nullptr>
+ std::unique_ptr<trie_node> burst(hash_node& node) {
+ /**
+ * We burst the node->array_hash() into multiple arrays hash. While doing
+ * so, we move each value in the node->array_hash() into the new arrays
+ * hash. After each move, we save a pointer to where the value has been
+ * moved. In case of exception, we rollback these values into the original
+ * node->array_hash().
+ */
+ std::vector<T*> moved_values_rollback;
+ moved_values_rollback.reserve(node.array_hash().size());
+
+ try {
+ const std::array<size_type, ALPHABET_SIZE> first_char_count =
+ get_first_char_count(node.array_hash().cbegin(),
+ node.array_hash().cend());
+
+ auto new_node = make_unique<trie_node>();
+ for (auto it = node.array_hash().begin(); it != node.array_hash().end();
+ ++it) {
+ if (it.key_size() == 0) {
+ new_node->val_node() = make_unique<value_node>(std::move(it.value()));
+ moved_values_rollback.push_back(
+ std::addressof(new_node->val_node()->m_value));
+ } else {
+ hash_node& hnode =
+ get_hash_node_for_char(first_char_count, *new_node, it.key()[0]);
+ auto it_insert = hnode.array_hash().insert_ks(
+ it.key() + 1, it.key_size() - 1, std::move(it.value()));
+ moved_values_rollback.push_back(
+ std::addressof(it_insert.first.value()));
+ }
+ }
+
+ tsl_ht_assert(new_node->val_node() != nullptr || !new_node->empty());
+ return new_node;
+ } catch (...) {
+ // Rollback the values
+ auto it = node.array_hash().begin();
+ for (std::size_t ivalue = 0; ivalue < moved_values_rollback.size();
+ ivalue++) {
+ it.value() = std::move(*moved_values_rollback[ivalue]);
+
+ ++it;
+ }
+
+ throw;
+ }
+ }
+
+ template <class U = T,
+ typename std::enable_if<!has_value<U>::value>::type* = nullptr>
+ std::unique_ptr<trie_node> burst(hash_node& node) {
+ const std::array<size_type, ALPHABET_SIZE> first_char_count =
+ get_first_char_count(node.array_hash().begin(),
+ node.array_hash().end());
+
+ auto new_node = make_unique<trie_node>();
+ for (auto it = node.array_hash().cbegin(); it != node.array_hash().cend();
+ ++it) {
+ if (it.key_size() == 0) {
+ new_node->val_node() = make_unique<value_node>();
+ } else {
+ hash_node& hnode =
+ get_hash_node_for_char(first_char_count, *new_node, it.key()[0]);
+ hnode.array_hash().insert_ks(it.key() + 1, it.key_size() - 1);
+ }
+ }
+
+ tsl_ht_assert(new_node->val_node() != nullptr || !new_node->empty());
+ return new_node;
+ }
+
+ std::array<size_type, ALPHABET_SIZE> get_first_char_count(
+ typename array_hash_type::const_iterator begin,
+ typename array_hash_type::const_iterator end) const {
+ std::array<size_type, ALPHABET_SIZE> count{{}};
+ for (auto it = begin; it != end; ++it) {
+ if (it.key_size() == 0) {
+ continue;
+ }
+
+ count[as_position(it.key()[0])]++;
+ }
+
+ return count;
+ }
+
+ hash_node& get_hash_node_for_char(
+ const std::array<size_type, ALPHABET_SIZE>& first_char_count,
+ trie_node& tnode, CharT for_char) {
+ if (tnode.child(for_char) == nullptr) {
+ const size_type nb_buckets =
+ size_type(std::ceil(float(first_char_count[as_position(for_char)] +
+ HASH_NODE_DEFAULT_INIT_BUCKETS_COUNT / 2) /
+ m_max_load_factor));
+
+ tnode.set_child(for_char, make_unique<hash_node>(nb_buckets, m_hash,
+ m_max_load_factor));
+ }
+
+ return tnode.child(for_char)->as_hash_node();
+ }
+
+ iterator mutable_iterator(const_iterator it) noexcept {
+ // end iterator or reading from a trie node value
+ if (it.m_current_hash_node == nullptr || it.m_read_trie_node_value) {
+ typename array_hash_type::iterator default_it;
+
+ return iterator(const_cast<trie_node*>(it.m_current_trie_node), nullptr,
+ default_it, default_it, it.m_read_trie_node_value);
+ } else {
+ hash_node* hnode = const_cast<hash_node*>(it.m_current_hash_node);
+ return iterator(
+ const_cast<trie_node*>(it.m_current_trie_node), hnode,
+ hnode->array_hash().mutable_iterator(it.m_array_hash_iterator),
+ hnode->array_hash().mutable_iterator(it.m_array_hash_end_iterator),
+ it.m_read_trie_node_value);
+ }
+ }
+
+ prefix_iterator mutable_iterator(const_prefix_iterator it) noexcept {
+ // end iterator or reading from a trie node value
+ if (it.m_current_hash_node == nullptr || it.m_read_trie_node_value) {
+ typename array_hash_type::iterator default_it;
+
+ return prefix_iterator(const_cast<trie_node*>(it.m_current_trie_node),
+ nullptr, default_it, default_it,
+ it.m_read_trie_node_value, "");
+ } else {
+ hash_node* hnode = const_cast<hash_node*>(it.m_current_hash_node);
+ return prefix_iterator(
+ const_cast<trie_node*>(it.m_current_trie_node), hnode,
+ hnode->array_hash().mutable_iterator(it.m_array_hash_iterator),
+ hnode->array_hash().mutable_iterator(it.m_array_hash_end_iterator),
+ it.m_read_trie_node_value, it.m_prefix_filter);
+ }
+ }
+
+ template <class Serializer>
+ void serialize_impl(Serializer& serializer) const {
+ const slz_size_type version = SERIALIZATION_PROTOCOL_VERSION;
+ serializer(version);
+
+ const slz_size_type nb_elements = m_nb_elements;
+ serializer(nb_elements);
+
+ const float max_load_factor = m_max_load_factor;
+ serializer(max_load_factor);
+
+ const slz_size_type burst_threshold = m_burst_threshold;
+ serializer(burst_threshold);
+
+ std::basic_string<CharT> str_buffer;
+
+ auto it = begin();
+ auto last = end();
+
+ while (it != last) {
+ // Serialize trie node value
+ if (it.m_read_trie_node_value) {
+ const CharT node_type =
+ static_cast<typename std::underlying_type<slz_node_type>::type>(
+ slz_node_type::TRIE_NODE);
+ serializer(&node_type, 1);
+
+ it.key(str_buffer);
+
+ const slz_size_type str_size = str_buffer.size();
+ serializer(str_size);
+ serializer(str_buffer.data(), str_buffer.size());
+ serialize_value(serializer, it);
+
+ ++it;
+ }
+ // Serialize hash node values
+ else {
+ const CharT node_type =
+ static_cast<typename std::underlying_type<slz_node_type>::type>(
+ slz_node_type::HASH_NODE);
+ serializer(&node_type, 1);
+
+ it.hash_node_prefix(str_buffer);
+
+ const slz_size_type str_size = str_buffer.size();
+ serializer(str_size);
+ serializer(str_buffer.data(), str_buffer.size());
+
+ const hash_node* hnode = it.m_current_hash_node;
+ tsl_ht_assert(hnode != nullptr);
+ hnode->array_hash().serialize(serializer);
+
+ it.skip_hash_node();
+ }
+ }
+ }
+
+ template <class Serializer, class U = T,
+ typename std::enable_if<!has_value<U>::value>::type* = nullptr>
+ void serialize_value(Serializer& /*serializer*/,
+ const_iterator /*it*/) const {}
+
+ template <class Serializer, class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ void serialize_value(Serializer& serializer, const_iterator it) const {
+ serializer(it.value());
+ }
+
+ template <class Deserializer>
+ void deserialize_impl(Deserializer& deserializer, bool hash_compatible) {
+ tsl_ht_assert(m_nb_elements == 0 &&
+ m_root == nullptr); // Current trie must be empty
+
+ const slz_size_type version =
+ deserialize_value<slz_size_type>(deserializer);
+ // For now we only have one version of the serialization protocol.
+ // If it doesn't match there is a problem with the file.
+ if (version != SERIALIZATION_PROTOCOL_VERSION) {
+ throw std::runtime_error(
+ "Can't deserialize the htrie_map/set. The protocol version header is "
+ "invalid.");
+ }
+
+ const slz_size_type nb_elements =
+ deserialize_value<slz_size_type>(deserializer);
+ const float max_load_factor = deserialize_value<float>(deserializer);
+ const slz_size_type burst_threshold =
+ deserialize_value<slz_size_type>(deserializer);
+
+ this->burst_threshold(numeric_cast<std::size_t>(
+ burst_threshold, "Deserialized burst_threshold is too big."));
+ this->max_load_factor(max_load_factor);
+
+ std::vector<CharT> str_buffer;
+ while (m_nb_elements < nb_elements) {
+ CharT node_type_marker;
+ deserializer(&node_type_marker, 1);
+
+ static_assert(
+ std::is_same<
+ CharT, typename std::underlying_type<slz_node_type>::type>::value,
+ "");
+ const slz_node_type node_type =
+ static_cast<slz_node_type>(node_type_marker);
+ if (node_type == slz_node_type::TRIE_NODE) {
+ const std::size_t str_size = numeric_cast<std::size_t>(
+ deserialize_value<slz_size_type>(deserializer),
+ "Deserialized str_size is too big.");
+
+ str_buffer.resize(str_size);
+ deserializer(str_buffer.data(), str_size);
+
+ trie_node* current_node =
+ insert_prefix_trie_nodes(str_buffer.data(), str_size);
+ deserialize_value_node(deserializer, current_node);
+ m_nb_elements++;
+ } else if (node_type == slz_node_type::HASH_NODE) {
+ const std::size_t str_size = numeric_cast<std::size_t>(
+ deserialize_value<slz_size_type>(deserializer),
+ "Deserialized str_size is too big.");
+
+ if (str_size == 0) {
+ tsl_ht_assert(m_nb_elements == 0 && !m_root);
+
+ m_root = make_unique<hash_node>(
+ array_hash_type::deserialize(deserializer, hash_compatible));
+ m_nb_elements += m_root->as_hash_node().array_hash().size();
+
+ tsl_ht_assert(m_nb_elements == nb_elements);
+ } else {
+ str_buffer.resize(str_size);
+ deserializer(str_buffer.data(), str_size);
+
+ auto hnode = make_unique<hash_node>(
+ array_hash_type::deserialize(deserializer, hash_compatible));
+ m_nb_elements += hnode->array_hash().size();
+
+ trie_node* current_node =
+ insert_prefix_trie_nodes(str_buffer.data(), str_size - 1);
+ current_node->set_child(str_buffer[str_size - 1], std::move(hnode));
+ }
+ } else {
+ throw std::runtime_error("Unknown deserialized node type.");
+ }
+ }
+
+ tsl_ht_assert(m_nb_elements == nb_elements);
+ }
+
+ trie_node* insert_prefix_trie_nodes(const CharT* prefix,
+ std::size_t prefix_size) {
+ if (m_root == nullptr) {
+ m_root = make_unique<trie_node>();
+ }
+
+ trie_node* current_node = &m_root->as_trie_node();
+ for (std::size_t iprefix = 0; iprefix < prefix_size; iprefix++) {
+ if (current_node->child(prefix[iprefix]) == nullptr) {
+ current_node->set_child(prefix[iprefix], make_unique<trie_node>());
+ }
+
+ current_node = &current_node->child(prefix[iprefix])->as_trie_node();
+ }
+
+ return current_node;
+ }
+
+ template <class Deserializer, class U = T,
+ typename std::enable_if<!has_value<U>::value>::type* = nullptr>
+ void deserialize_value_node(Deserializer& /*deserializer*/,
+ trie_node* current_node) {
+ tsl_ht_assert(!current_node->val_node());
+ current_node->val_node() = make_unique<value_node>();
+ }
+
+ template <class Deserializer, class U = T,
+ typename std::enable_if<has_value<U>::value>::type* = nullptr>
+ void deserialize_value_node(Deserializer& deserializer,
+ trie_node* current_node) {
+ tsl_ht_assert(!current_node->val_node());
+ current_node->val_node() =
+ make_unique<value_node>(deserialize_value<T>(deserializer));
+ }
+
+ template <class U, class Deserializer>
+ static U deserialize_value(Deserializer& deserializer) {
+ // MSVC < 2017 is not conformant, circumvent the problem by removing the
+ // template keyword
+#if defined(_MSC_VER) && _MSC_VER < 1910
+ return deserializer.Deserializer::operator()<U>();
+#else
+ return deserializer.Deserializer::template operator()<U>();
+#endif
+ }
+
+ // Same as std::make_unique for non-array types which is only available in
+ // C++14 (we need to support C++11).
+ template <typename U, typename... Args>
+ static std::unique_ptr<U> make_unique(Args&&... args) {
+ return std::unique_ptr<U>(new U(std::forward<Args>(args)...));
+ }
+
+ public:
+ static constexpr float HASH_NODE_DEFAULT_MAX_LOAD_FACTOR = 8.0f;
+ static const size_type DEFAULT_BURST_THRESHOLD = 16384;
+
+ private:
+ /**
+ * Fixed size type used to represent size_type values on serialization. Need
+ * to be big enough to represent a std::size_t on 32 and 64 bits platforms,
+ * and must be the same size on both platforms.
+ */
+ using slz_size_type = std::uint64_t;
+ enum class slz_node_type : CharT { TRIE_NODE = 0, HASH_NODE = 1 };
+
+ /**
+ * Protocol version currenlty used for serialization.
+ */
+ static const slz_size_type SERIALIZATION_PROTOCOL_VERSION = 1;
+
+ static const size_type HASH_NODE_DEFAULT_INIT_BUCKETS_COUNT = 32;
+ static const size_type MIN_BURST_THRESHOLD = 4;
+
+ std::unique_ptr<anode> m_root;
+ size_type m_nb_elements;
+ Hash m_hash;
+ float m_max_load_factor;
+ size_type m_burst_threshold;
+};
+
+} // end namespace detail_htrie_hash
+} // end namespace tsl
+
+#endif
diff --git a/include/tsl/htrie_map.h b/include/tsl/htrie_map.h
new file mode 100644
index 00000000..c601ac8d
--- /dev/null
+++ b/include/tsl/htrie_map.h
@@ -0,0 +1,668 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_HTRIE_MAP_H
+#define TSL_HTRIE_MAP_H
+
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <string>
+#include <utility>
+
+#include "htrie_hash.h"
+
+namespace tsl {
+
+/**
+ * Implementation of a hat-trie map.
+ *
+ * The value T must be either nothrow move-constructible/assignable,
+ * copy-constructible or both.
+ *
+ * The size of a key string is limited to std::numeric_limits<KeySizeT>::max()
+ * - 1. That is 65 535 characters by default, but can be raised with the
+ * KeySizeT template parameter. See max_key_size() for an easy access to this
+ * limit.
+ *
+ * Iterators invalidation:
+ * - clear, operator=: always invalidate the iterators.
+ * - insert, emplace, operator[]: always invalidate the iterators.
+ * - erase: always invalidate the iterators.
+ */
+template <class CharT, class T, class Hash = tsl::ah::str_hash<CharT>,
+ class KeySizeT = std::uint16_t>
+class htrie_map {
+ private:
+ template <typename U>
+ using is_iterator = tsl::detail_array_hash::is_iterator<U>;
+
+ using ht = tsl::detail_htrie_hash::htrie_hash<CharT, T, Hash, KeySizeT>;
+
+ public:
+ using char_type = typename ht::char_type;
+ using mapped_type = T;
+ using key_size_type = typename ht::key_size_type;
+ using size_type = typename ht::size_type;
+ using hasher = typename ht::hasher;
+ using iterator = typename ht::iterator;
+ using const_iterator = typename ht::const_iterator;
+ using prefix_iterator = typename ht::prefix_iterator;
+ using const_prefix_iterator = typename ht::const_prefix_iterator;
+
+ public:
+ explicit htrie_map(const Hash& hash = Hash())
+ : m_ht(hash, ht::HASH_NODE_DEFAULT_MAX_LOAD_FACTOR,
+ ht::DEFAULT_BURST_THRESHOLD) {}
+
+ explicit htrie_map(size_type burst_threshold, const Hash& hash = Hash())
+ : m_ht(hash, ht::HASH_NODE_DEFAULT_MAX_LOAD_FACTOR, burst_threshold) {}
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ htrie_map(InputIt first, InputIt last, const Hash& hash = Hash())
+ : htrie_map(hash) {
+ insert(first, last);
+ }
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ htrie_map(
+ std::initializer_list<std::pair<std::basic_string_view<CharT>, T>> init,
+ const Hash& hash = Hash())
+ : htrie_map(hash) {
+ insert(init);
+ }
+#else
+ htrie_map(std::initializer_list<std::pair<const CharT*, T>> init,
+ const Hash& hash = Hash())
+ : htrie_map(hash) {
+ insert(init);
+ }
+#endif
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ htrie_map& operator=(
+ std::initializer_list<std::pair<std::basic_string_view<CharT>, T>>
+ ilist) {
+ clear();
+ insert(ilist);
+
+ return *this;
+ }
+#else
+ htrie_map& operator=(
+ std::initializer_list<std::pair<const CharT*, T>> ilist) {
+ clear();
+ insert(ilist);
+
+ return *this;
+ }
+#endif
+
+ /*
+ * Iterators
+ */
+ iterator begin() noexcept { return m_ht.begin(); }
+ const_iterator begin() const noexcept { return m_ht.begin(); }
+ const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
+
+ iterator end() noexcept { return m_ht.end(); }
+ const_iterator end() const noexcept { return m_ht.end(); }
+ const_iterator cend() const noexcept { return m_ht.cend(); }
+
+ /*
+ * Capacity
+ */
+ bool empty() const noexcept { return m_ht.empty(); }
+ size_type size() const noexcept { return m_ht.size(); }
+ size_type max_size() const noexcept { return m_ht.max_size(); }
+ size_type max_key_size() const noexcept { return m_ht.max_key_size(); }
+
+ /**
+ * Call shrink_to_fit() on each hash node of the hat-trie to reduce its size.
+ */
+ void shrink_to_fit() { m_ht.shrink_to_fit(); }
+
+ /*
+ * Modifiers
+ */
+ void clear() noexcept { m_ht.clear(); }
+
+ std::pair<iterator, bool> insert_ks(const CharT* key, size_type key_size,
+ const T& value) {
+ return m_ht.insert(key, key_size, value);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ std::pair<iterator, bool> insert(const std::basic_string_view<CharT>& key,
+ const T& value) {
+ return m_ht.insert(key.data(), key.size(), value);
+ }
+#else
+ std::pair<iterator, bool> insert(const CharT* key, const T& value) {
+ return m_ht.insert(key, std::strlen(key), value);
+ }
+
+ std::pair<iterator, bool> insert(const std::basic_string<CharT>& key,
+ const T& value) {
+ return m_ht.insert(key.data(), key.size(), value);
+ }
+#endif
+
+ std::pair<iterator, bool> insert_ks(const CharT* key, size_type key_size,
+ T&& value) {
+ return m_ht.insert(key, key_size, std::move(value));
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ std::pair<iterator, bool> insert(const std::basic_string_view<CharT>& key,
+ T&& value) {
+ return m_ht.insert(key.data(), key.size(), std::move(value));
+ }
+#else
+ std::pair<iterator, bool> insert(const CharT* key, T&& value) {
+ return m_ht.insert(key, std::strlen(key), std::move(value));
+ }
+
+ std::pair<iterator, bool> insert(const std::basic_string<CharT>& key,
+ T&& value) {
+ return m_ht.insert(key.data(), key.size(), std::move(value));
+ }
+#endif
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ void insert(InputIt first, InputIt last) {
+ for (auto it = first; it != last; ++it) {
+ insert_pair(*it);
+ }
+ }
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ void insert(std::initializer_list<std::pair<std::basic_string_view<CharT>, T>>
+ ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#else
+ void insert(std::initializer_list<std::pair<const CharT*, T>> ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#endif
+
+ template <class... Args>
+ std::pair<iterator, bool> emplace_ks(const CharT* key, size_type key_size,
+ Args&&... args) {
+ return m_ht.insert(key, key_size, std::forward<Args>(args)...);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ template <class... Args>
+ std::pair<iterator, bool> emplace(const std::basic_string_view<CharT>& key,
+ Args&&... args) {
+ return m_ht.insert(key.data(), key.size(), std::forward<Args>(args)...);
+ }
+#else
+ template <class... Args>
+ std::pair<iterator, bool> emplace(const CharT* key, Args&&... args) {
+ return m_ht.insert(key, std::strlen(key), std::forward<Args>(args)...);
+ }
+
+ template <class... Args>
+ std::pair<iterator, bool> emplace(const std::basic_string<CharT>& key,
+ Args&&... args) {
+ return m_ht.insert(key.data(), key.size(), std::forward<Args>(args)...);
+ }
+#endif
+
+ iterator erase(const_iterator pos) { return m_ht.erase(pos); }
+ iterator erase(const_iterator first, const_iterator last) {
+ return m_ht.erase(first, last);
+ }
+
+ size_type erase_ks(const CharT* key, size_type key_size) {
+ return m_ht.erase(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ size_type erase(const std::basic_string_view<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#else
+ size_type erase(const CharT* key) {
+ return m_ht.erase(key, std::strlen(key));
+ }
+
+ size_type erase(const std::basic_string<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#endif
+
+ /**
+ * Erase all the elements which have 'prefix' as prefix. Return the number of
+ * erase elements.
+ */
+ size_type erase_prefix_ks(const CharT* prefix, size_type prefix_size) {
+ return m_ht.erase_prefix(prefix, prefix_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ /**
+ * @copydoc erase_prefix_ks(const CharT* prefix, size_type prefix_size)
+ */
+ size_type erase_prefix(const std::basic_string_view<CharT>& prefix) {
+ return m_ht.erase_prefix(prefix.data(), prefix.size());
+ }
+#else
+ /**
+ * @copydoc erase_prefix_ks(const CharT* prefix, size_type prefix_size)
+ */
+ size_type erase_prefix(const CharT* prefix) {
+ return m_ht.erase_prefix(prefix, std::strlen(prefix));
+ }
+
+ /**
+ * @copydoc erase_prefix_ks(const CharT* prefix, size_type prefix_size)
+ */
+ size_type erase_prefix(const std::basic_string<CharT>& prefix) {
+ return m_ht.erase_prefix(prefix.data(), prefix.size());
+ }
+#endif
+
+ void swap(htrie_map& other) { other.m_ht.swap(m_ht); }
+
+ /*
+ * Lookup
+ */
+ T& at_ks(const CharT* key, size_type key_size) {
+ return m_ht.at(key, key_size);
+ }
+ const T& at_ks(const CharT* key, size_type key_size) const {
+ return m_ht.at(key, key_size);
+ }
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ T& at(const std::basic_string_view<CharT>& key) {
+ return m_ht.at(key.data(), key.size());
+ }
+ const T& at(const std::basic_string_view<CharT>& key) const {
+ return m_ht.at(key.data(), key.size());
+ }
+#else
+ T& at(const CharT* key) { return m_ht.at(key, std::strlen(key)); }
+ const T& at(const CharT* key) const { return m_ht.at(key, std::strlen(key)); }
+
+ T& at(const std::basic_string<CharT>& key) {
+ return m_ht.at(key.data(), key.size());
+ }
+ const T& at(const std::basic_string<CharT>& key) const {
+ return m_ht.at(key.data(), key.size());
+ }
+#endif
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ T& operator[](const std::basic_string_view<CharT>& key) {
+ return m_ht.access_operator(key.data(), key.size());
+ }
+#else
+ T& operator[](const CharT* key) {
+ return m_ht.access_operator(key, std::strlen(key));
+ }
+ T& operator[](const std::basic_string<CharT>& key) {
+ return m_ht.access_operator(key.data(), key.size());
+ }
+#endif
+
+ size_type count_ks(const CharT* key, size_type key_size) const {
+ return m_ht.count(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ size_type count(const std::basic_string_view<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#else
+ size_type count(const CharT* key) const {
+ return m_ht.count(key, std::strlen(key));
+ }
+ size_type count(const std::basic_string<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#endif
+
+ iterator find_ks(const CharT* key, size_type key_size) {
+ return m_ht.find(key, key_size);
+ }
+
+ const_iterator find_ks(const CharT* key, size_type key_size) const {
+ return m_ht.find(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ iterator find(const std::basic_string_view<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string_view<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#else
+ iterator find(const CharT* key) { return m_ht.find(key, std::strlen(key)); }
+
+ const_iterator find(const CharT* key) const {
+ return m_ht.find(key, std::strlen(key));
+ }
+
+ iterator find(const std::basic_string<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#endif
+
+ std::pair<iterator, iterator> equal_range_ks(const CharT* key,
+ size_type key_size) {
+ return m_ht.equal_range(key, key_size);
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range_ks(
+ const CharT* key, size_type key_size) const {
+ return m_ht.equal_range(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string_view<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string_view<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, iterator> equal_range(const CharT* key) {
+ return m_ht.equal_range(key, std::strlen(key));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key) const {
+ return m_ht.equal_range(key, std::strlen(key));
+ }
+
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#endif
+
+ /**
+ * Return a range containing all the elements which have 'prefix' as prefix.
+ * The range is defined by a pair of iterator, the first being the begin
+ * iterator and the second being the end iterator.
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range_ks(
+ const CharT* prefix, size_type prefix_size) {
+ return m_ht.equal_prefix_range(prefix, prefix_size);
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range_ks(
+ const CharT* prefix, size_type prefix_size) const {
+ return m_ht.equal_prefix_range(prefix, prefix_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const std::basic_string_view<CharT>& prefix) {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const std::basic_string_view<CharT>& prefix) const {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+#else
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const CharT* prefix) {
+ return m_ht.equal_prefix_range(prefix, std::strlen(prefix));
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const CharT* prefix) const {
+ return m_ht.equal_prefix_range(prefix, std::strlen(prefix));
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const std::basic_string<CharT>& prefix) {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const std::basic_string<CharT>& prefix) const {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+#endif
+
+ /**
+ * Return the element in the trie which is the longest prefix of `key`. If no
+ * element in the trie is a prefix of `key`, the end iterator is returned.
+ *
+ * Example:
+ *
+ * tsl::htrie_map<char, int> map = {{"/foo", 1}, {"/foo/bar", 1}};
+ *
+ * map.longest_prefix("/foo"); // returns {"/foo", 1}
+ * map.longest_prefix("/foo/baz"); // returns {"/foo", 1}
+ * map.longest_prefix("/foo/bar/baz"); // returns {"/foo/bar", 1}
+ * map.longest_prefix("/foo/bar/"); // returns {"/foo/bar", 1}
+ * map.longest_prefix("/bar"); // returns end()
+ * map.longest_prefix(""); // returns end()
+ */
+ iterator longest_prefix_ks(const CharT* key, size_type key_size) {
+ return m_ht.longest_prefix(key, key_size);
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix_ks(const CharT* key, size_type key_size) const {
+ return m_ht.longest_prefix(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ iterator longest_prefix(const std::basic_string_view<CharT>& key) {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix(
+ const std::basic_string_view<CharT>& key) const {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+#else
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ iterator longest_prefix(const CharT* key) {
+ return m_ht.longest_prefix(key, std::strlen(key));
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix(const CharT* key) const {
+ return m_ht.longest_prefix(key, std::strlen(key));
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ iterator longest_prefix(const std::basic_string<CharT>& key) {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix(const std::basic_string<CharT>& key) const {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+#endif
+
+ /*
+ * Hash policy
+ */
+ float max_load_factor() const { return m_ht.max_load_factor(); }
+ void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
+
+ /*
+ * Burst policy
+ */
+ size_type burst_threshold() const { return m_ht.burst_threshold(); }
+ void burst_threshold(size_type threshold) { m_ht.burst_threshold(threshold); }
+
+ /*
+ * Observers
+ */
+ hasher hash_function() const { return m_ht.hash_function(); }
+
+ /*
+ * Other
+ */
+
+ /**
+ * Serialize the map through the `serializer` parameter.
+ *
+ * The `serializer` parameter must be a function object that supports the
+ * following calls:
+ * - `void operator()(const U& value);` where the types `std::uint64_t`,
+ * `float` and `T` must be supported for U.
+ * - `void operator()(const CharT* value, std::size_t value_size);`
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, ...) of the types it serializes in the hands of the `Serializer`
+ * function object if compatibility is required.
+ */
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ m_ht.serialize(serializer);
+ }
+
+ /**
+ * Deserialize a previously serialized map through the `deserializer`
+ * parameter.
+ *
+ * The `deserializer` parameter must be a function object that supports the
+ * following calls:
+ * - `template<typename U> U operator()();` where the types `std::uint64_t`,
+ * `float` and `T` must be supported for U.
+ * - `void operator()(CharT* value_out, std::size_t value_size);`
+ *
+ * If the deserialized hash map part of the hat-trie is hash compatible with
+ * the serialized map, the deserialization process can be sped up by setting
+ * `hash_compatible` to true. To be hash compatible, the Hash (take care of
+ * the 32-bits vs 64 bits), and KeySizeT must behave the same than the ones
+ * used in the serialized map. Otherwise the behaviour is undefined with
+ * `hash_compatible` sets to true.
+ *
+ * The behaviour is undefined if the type `CharT` and `T` of the `htrie_map`
+ * are not the same as the types used during serialization.
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, size of int, ...) of the types it deserializes in the hands of the
+ * `Deserializer` function object if compatibility is required.
+ */
+ template <class Deserializer>
+ static htrie_map deserialize(Deserializer& deserializer,
+ bool hash_compatible = false) {
+ htrie_map map;
+ map.m_ht.deserialize(deserializer, hash_compatible);
+
+ return map;
+ }
+
+ friend bool operator==(const htrie_map& lhs, const htrie_map& rhs) {
+ if (lhs.size() != rhs.size()) {
+ return false;
+ }
+
+ std::string key_buffer;
+ for (auto it = lhs.cbegin(); it != lhs.cend(); ++it) {
+ it.key(key_buffer);
+
+ const auto it_element_rhs = rhs.find(key_buffer);
+ if (it_element_rhs == rhs.cend() ||
+ it.value() != it_element_rhs.value()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ friend bool operator!=(const htrie_map& lhs, const htrie_map& rhs) {
+ return !operator==(lhs, rhs);
+ }
+
+ friend void swap(htrie_map& lhs, htrie_map& rhs) { lhs.swap(rhs); }
+
+ private:
+ template <class U, class V>
+ void insert_pair(const std::pair<U, V>& value) {
+ insert(value.first, value.second);
+ }
+
+ template <class U, class V>
+ void insert_pair(std::pair<U, V>&& value) {
+ insert(value.first, std::move(value.second));
+ }
+
+ private:
+ ht m_ht;
+};
+
+} // end namespace tsl
+
+#endif
diff --git a/include/tsl/htrie_set.h b/include/tsl/htrie_set.h
new file mode 100644
index 00000000..ea71f0e9
--- /dev/null
+++ b/include/tsl/htrie_set.h
@@ -0,0 +1,578 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_HTRIE_SET_H
+#define TSL_HTRIE_SET_H
+
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <string>
+#include <utility>
+
+#include "htrie_hash.h"
+
+namespace tsl {
+
+/**
+ * Implementation of a hat-trie set.
+ *
+ * The size of a key string is limited to std::numeric_limits<KeySizeT>::max()
+ * - 1. That is 65 535 characters by default, but can be raised with the
+ * KeySizeT template parameter. See max_key_size() for an easy access to this
+ * limit.
+ *
+ * Iterators invalidation:
+ * - clear, operator=: always invalidate the iterators.
+ * - insert: always invalidate the iterators.
+ * - erase: always invalidate the iterators.
+ */
+template <class CharT, class Hash = tsl::ah::str_hash<CharT>,
+ class KeySizeT = std::uint16_t>
+class htrie_set {
+ private:
+ template <typename U>
+ using is_iterator = tsl::detail_array_hash::is_iterator<U>;
+
+ using ht = tsl::detail_htrie_hash::htrie_hash<CharT, void, Hash, KeySizeT>;
+
+ public:
+ using char_type = typename ht::char_type;
+ using key_size_type = typename ht::key_size_type;
+ using size_type = typename ht::size_type;
+ using hasher = typename ht::hasher;
+ using iterator = typename ht::iterator;
+ using const_iterator = typename ht::const_iterator;
+ using prefix_iterator = typename ht::prefix_iterator;
+ using const_prefix_iterator = typename ht::const_prefix_iterator;
+
+ public:
+ explicit htrie_set(const Hash& hash = Hash())
+ : m_ht(hash, ht::HASH_NODE_DEFAULT_MAX_LOAD_FACTOR,
+ ht::DEFAULT_BURST_THRESHOLD) {}
+
+ explicit htrie_set(size_type burst_threshold, const Hash& hash = Hash())
+ : m_ht(hash, ht::HASH_NODE_DEFAULT_MAX_LOAD_FACTOR, burst_threshold) {}
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ htrie_set(InputIt first, InputIt last, const Hash& hash = Hash())
+ : htrie_set(hash) {
+ insert(first, last);
+ }
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ htrie_set(std::initializer_list<std::basic_string_view<CharT>> init,
+ const Hash& hash = Hash())
+ : htrie_set(hash) {
+ insert(init);
+ }
+#else
+ htrie_set(std::initializer_list<const CharT*> init, const Hash& hash = Hash())
+ : htrie_set(hash) {
+ insert(init);
+ }
+#endif
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ htrie_set& operator=(
+ std::initializer_list<std::basic_string_view<CharT>> ilist) {
+ clear();
+ insert(ilist);
+
+ return *this;
+ }
+#else
+ htrie_set& operator=(std::initializer_list<const CharT*> ilist) {
+ clear();
+ insert(ilist);
+
+ return *this;
+ }
+#endif
+
+ /*
+ * Iterators
+ */
+ iterator begin() noexcept { return m_ht.begin(); }
+ const_iterator begin() const noexcept { return m_ht.begin(); }
+ const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
+
+ iterator end() noexcept { return m_ht.end(); }
+ const_iterator end() const noexcept { return m_ht.end(); }
+ const_iterator cend() const noexcept { return m_ht.cend(); }
+
+ /*
+ * Capacity
+ */
+ bool empty() const noexcept { return m_ht.empty(); }
+ size_type size() const noexcept { return m_ht.size(); }
+ size_type max_size() const noexcept { return m_ht.max_size(); }
+ size_type max_key_size() const noexcept { return m_ht.max_key_size(); }
+
+ /**
+ * Call shrink_to_fit() on each hash node of the hat-trie to reduce its size.
+ */
+ void shrink_to_fit() { m_ht.shrink_to_fit(); }
+
+ /*
+ * Modifiers
+ */
+ void clear() noexcept { m_ht.clear(); }
+
+ std::pair<iterator, bool> insert_ks(const CharT* key, size_type key_size) {
+ return m_ht.insert(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ std::pair<iterator, bool> insert(const std::basic_string_view<CharT>& key) {
+ return m_ht.insert(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, bool> insert(const CharT* key) {
+ return m_ht.insert(key, std::strlen(key));
+ }
+
+ std::pair<iterator, bool> insert(const std::basic_string<CharT>& key) {
+ return m_ht.insert(key.data(), key.size());
+ }
+#endif
+
+ template <class InputIt, typename std::enable_if<
+ is_iterator<InputIt>::value>::type* = nullptr>
+ void insert(InputIt first, InputIt last) {
+ for (auto it = first; it != last; ++it) {
+ insert(*it);
+ }
+ }
+
+#ifdef TSL_HT_HAS_STRING_VIEW
+ void insert(std::initializer_list<std::basic_string_view<CharT>> ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#else
+ void insert(std::initializer_list<const CharT*> ilist) {
+ insert(ilist.begin(), ilist.end());
+ }
+#endif
+
+ std::pair<iterator, bool> emplace_ks(const CharT* key, size_type key_size) {
+ return m_ht.insert(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ std::pair<iterator, bool> emplace(const std::basic_string_view<CharT>& key) {
+ return m_ht.insert(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, bool> emplace(const CharT* key) {
+ return m_ht.insert(key, std::strlen(key));
+ }
+
+ std::pair<iterator, bool> emplace(const std::basic_string<CharT>& key) {
+ return m_ht.insert(key.data(), key.size());
+ }
+#endif
+
+ iterator erase(const_iterator pos) { return m_ht.erase(pos); }
+ iterator erase(const_iterator first, const_iterator last) {
+ return m_ht.erase(first, last);
+ }
+
+ size_type erase_ks(const CharT* key, size_type key_size) {
+ return m_ht.erase(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ size_type erase(const std::basic_string_view<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#else
+ size_type erase(const CharT* key) {
+ return m_ht.erase(key, std::strlen(key));
+ }
+
+ size_type erase(const std::basic_string<CharT>& key) {
+ return m_ht.erase(key.data(), key.size());
+ }
+#endif
+
+ /**
+ * Erase all the elements which have 'prefix' as prefix. Return the number of
+ * erase elements.
+ */
+ size_type erase_prefix_ks(const CharT* prefix, size_type prefix_size) {
+ return m_ht.erase_prefix(prefix, prefix_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ /**
+ * @copydoc erase_prefix_ks(const CharT* prefix, size_type prefix_size)
+ */
+ size_type erase_prefix(const std::basic_string_view<CharT>& prefix) {
+ return m_ht.erase_prefix(prefix.data(), prefix.size());
+ }
+#else
+ /**
+ * @copydoc erase_prefix_ks(const CharT* prefix, size_type prefix_size)
+ */
+ size_type erase_prefix(const CharT* prefix) {
+ return m_ht.erase_prefix(prefix, std::strlen(prefix));
+ }
+
+ /**
+ * @copydoc erase_prefix_ks(const CharT* prefix, size_type prefix_size)
+ */
+ size_type erase_prefix(const std::basic_string<CharT>& prefix) {
+ return m_ht.erase_prefix(prefix.data(), prefix.size());
+ }
+#endif
+
+ void swap(htrie_set& other) { other.m_ht.swap(m_ht); }
+
+ /*
+ * Lookup
+ */
+ size_type count_ks(const CharT* key, size_type key_size) const {
+ return m_ht.count(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ size_type count(const std::basic_string_view<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#else
+ size_type count(const CharT* key) const {
+ return m_ht.count(key, std::strlen(key));
+ }
+ size_type count(const std::basic_string<CharT>& key) const {
+ return m_ht.count(key.data(), key.size());
+ }
+#endif
+
+ iterator find_ks(const CharT* key, size_type key_size) {
+ return m_ht.find(key, key_size);
+ }
+
+ const_iterator find_ks(const CharT* key, size_type key_size) const {
+ return m_ht.find(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ iterator find(const std::basic_string_view<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string_view<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#else
+ iterator find(const CharT* key) { return m_ht.find(key, std::strlen(key)); }
+
+ const_iterator find(const CharT* key) const {
+ return m_ht.find(key, std::strlen(key));
+ }
+
+ iterator find(const std::basic_string<CharT>& key) {
+ return m_ht.find(key.data(), key.size());
+ }
+
+ const_iterator find(const std::basic_string<CharT>& key) const {
+ return m_ht.find(key.data(), key.size());
+ }
+#endif
+
+ std::pair<iterator, iterator> equal_range_ks(const CharT* key,
+ size_type key_size) {
+ return m_ht.equal_range(key, key_size);
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range_ks(
+ const CharT* key, size_type key_size) const {
+ return m_ht.equal_range(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string_view<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string_view<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#else
+ std::pair<iterator, iterator> equal_range(const CharT* key) {
+ return m_ht.equal_range(key, std::strlen(key));
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const CharT* key) const {
+ return m_ht.equal_range(key, std::strlen(key));
+ }
+
+ std::pair<iterator, iterator> equal_range(
+ const std::basic_string<CharT>& key) {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+
+ std::pair<const_iterator, const_iterator> equal_range(
+ const std::basic_string<CharT>& key) const {
+ return m_ht.equal_range(key.data(), key.size());
+ }
+#endif
+
+ /**
+ * Return a range containing all the elements which have 'prefix' as prefix.
+ * The range is defined by a pair of iterator, the first being the begin
+ * iterator and the second being the end iterator.
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range_ks(
+ const CharT* prefix, size_type prefix_size) {
+ return m_ht.equal_prefix_range(prefix, prefix_size);
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range_ks(
+ const CharT* prefix, size_type prefix_size) const {
+ return m_ht.equal_prefix_range(prefix, prefix_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const std::basic_string_view<CharT>& prefix) {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const std::basic_string_view<CharT>& prefix) const {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+#else
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const CharT* prefix) {
+ return m_ht.equal_prefix_range(prefix, std::strlen(prefix));
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const CharT* prefix) const {
+ return m_ht.equal_prefix_range(prefix, std::strlen(prefix));
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<prefix_iterator, prefix_iterator> equal_prefix_range(
+ const std::basic_string<CharT>& prefix) {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+
+ /**
+ * @copydoc equal_prefix_range_ks(const CharT* prefix, size_type prefix_size)
+ */
+ std::pair<const_prefix_iterator, const_prefix_iterator> equal_prefix_range(
+ const std::basic_string<CharT>& prefix) const {
+ return m_ht.equal_prefix_range(prefix.data(), prefix.size());
+ }
+#endif
+
+ /**
+ * Return the element in the trie which is the longest prefix of `key`. If no
+ * element in the trie is a prefix of `key`, the end iterator is returned.
+ *
+ * Example:
+ *
+ * tsl::htrie_set<char> set = {"/foo", "/foo/bar"};
+ *
+ * set.longest_prefix("/foo"); // returns "/foo"
+ * set.longest_prefix("/foo/baz"); // returns "/foo"
+ * set.longest_prefix("/foo/bar/baz"); // returns "/foo/bar"
+ * set.longest_prefix("/foo/bar/"); // returns "/foo/bar"
+ * set.longest_prefix("/bar"); // returns end()
+ * set.longest_prefix(""); // returns end()
+ */
+ iterator longest_prefix_ks(const CharT* key, size_type key_size) {
+ return m_ht.longest_prefix(key, key_size);
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix_ks(const CharT* key, size_type key_size) const {
+ return m_ht.longest_prefix(key, key_size);
+ }
+#ifdef TSL_HT_HAS_STRING_VIEW
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ iterator longest_prefix(const std::basic_string_view<CharT>& key) {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix(
+ const std::basic_string_view<CharT>& key) const {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+#else
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ iterator longest_prefix(const CharT* key) {
+ return m_ht.longest_prefix(key, std::strlen(key));
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix(const CharT* key) const {
+ return m_ht.longest_prefix(key, std::strlen(key));
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ iterator longest_prefix(const std::basic_string<CharT>& key) {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+
+ /**
+ * @copydoc longest_prefix_ks(const CharT* key, size_type key_size)
+ */
+ const_iterator longest_prefix(const std::basic_string<CharT>& key) const {
+ return m_ht.longest_prefix(key.data(), key.size());
+ }
+#endif
+
+ /*
+ * Hash policy
+ */
+ float max_load_factor() const { return m_ht.max_load_factor(); }
+ void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
+
+ /*
+ * Burst policy
+ */
+ size_type burst_threshold() const { return m_ht.burst_threshold(); }
+ void burst_threshold(size_type threshold) { m_ht.burst_threshold(threshold); }
+
+ /*
+ * Observers
+ */
+ hasher hash_function() const { return m_ht.hash_function(); }
+
+ /*
+ * Other
+ */
+
+ /**
+ * Serialize the set through the `serializer` parameter.
+ *
+ * The `serializer` parameter must be a function object that supports the
+ * following calls:
+ * - `void operator()(const U& value);` where the types `std::uint64_t` and
+ * `float` must be supported for U.
+ * - `void operator()(const CharT* value, std::size_t value_size);`
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, ...) of the types it serializes in the hands of the `Serializer`
+ * function object if compatibility is required.
+ */
+ template <class Serializer>
+ void serialize(Serializer& serializer) const {
+ m_ht.serialize(serializer);
+ }
+
+ /**
+ * Deserialize a previously serialized set through the `deserializer`
+ * parameter.
+ *
+ * The `deserializer` parameter must be a function object that supports the
+ * following calls:
+ * - `template<typename U> U operator()();` where the types `std::uint64_t`
+ * and `float` must be supported for U.
+ * - `void operator()(CharT* value_out, std::size_t value_size);`
+ *
+ * If the deserialized hash set part of the hat-trie is hash compatible with
+ * the serialized set, the deserialization process can be sped up by setting
+ * `hash_compatible` to true. To be hash compatible, the Hash (take care of
+ * the 32-bits vs 64 bits), and KeySizeT must behave the same than the ones
+ * used in the serialized set. Otherwise the behaviour is undefined with
+ * `hash_compatible` sets to true.
+ *
+ * The behaviour is undefined if the type `CharT` of the `htrie_set` is not
+ * the same as the type used during serialization.
+ *
+ * The implementation leaves binary compatibility (endianness, IEEE 754 for
+ * floats, size of int, ...) of the types it deserializes in the hands of the
+ * `Deserializer` function object if compatibility is required.
+ */
+ template <class Deserializer>
+ static htrie_set deserialize(Deserializer& deserializer,
+ bool hash_compatible = false) {
+ htrie_set set;
+ set.m_ht.deserialize(deserializer, hash_compatible);
+
+ return set;
+ }
+
+ friend bool operator==(const htrie_set& lhs, const htrie_set& rhs) {
+ if (lhs.size() != rhs.size()) {
+ return false;
+ }
+
+ std::string key_buffer;
+ for (auto it = lhs.cbegin(); it != lhs.cend(); ++it) {
+ it.key(key_buffer);
+
+ const auto it_element_rhs = rhs.find(key_buffer);
+ if (it_element_rhs == rhs.cend()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ friend bool operator!=(const htrie_set& lhs, const htrie_set& rhs) {
+ return !operator==(lhs, rhs);
+ }
+
+ friend void swap(htrie_set& lhs, htrie_set& rhs) { lhs.swap(rhs); }
+
+ private:
+ ht m_ht;
+};
+
+} // end namespace tsl
+
+#endif
diff --git a/src/collection.cpp b/src/collection.cpp
index de964f9e..aa8a4cc2 100644
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@ -689,7 +689,10 @@ Option<nlohmann::json> Collection::search(const std::string & raw_query, const s
const size_t min_len_1typo,
const size_t min_len_2typo,
bool split_join_tokens,
- const size_t max_candidates) const {
+ const size_t max_candidates,
+ const std::vector<infix_t>& infixes,
+ const size_t max_extra_prefix,
+ const size_t max_extra_suffix) const {
std::shared_lock lock(mutex);
@@ -721,6 +724,13 @@ Option<nlohmann::json> Collection::search(const std::string & raw_query, const s
}
}
+ if(!search_fields.empty() && search_fields.size() != infixes.size()) {
+ if(infixes.size() != 1) {
+ return Option<nlohmann::json>(400, "Number of infix values in `infix` does not match "
+ "number of `query_by` fields.");
+ }
+ }
+
// process weights for search fields
std::vector<search_field_t> weighted_search_fields;
size_t max_weight = 20;
@@ -1005,7 +1015,8 @@ Option<nlohmann::json> Collection::search(const std::string & raw_query, const s
group_by_fields, group_limit, default_sorting_field, prioritize_exact_match,
exhaustive_search, 4, filter_overrides,
search_stop_millis,
- min_len_1typo, min_len_2typo, max_candidates);
+ min_len_1typo, min_len_2typo, max_candidates, infixes,
+ max_extra_prefix, max_extra_suffix);
index->run_search(search_params);
diff --git a/src/collection_manager.cpp b/src/collection_manager.cpp
index c2322b8c..0bc6695b 100644
--- a/src/collection_manager.cpp
+++ b/src/collection_manager.cpp
@@ -5,6 +5,7 @@
#include "collection_manager.h"
#include "batched_indexer.h"
#include "logger.h"
+#include "magic_enum.hpp"
constexpr const size_t CollectionManager::DEFAULT_NUM_MEMORY_SHARDS;
@@ -567,6 +568,10 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
const char *ENABLE_OVERRIDES = "enable_overrides";
const char *MAX_CANDIDATES = "max_candidates";
+ const char *INFIX = "infix";
+ const char *MAX_EXTRA_PREFIX = "max_extra_prefix";
+ const char *MAX_EXTRA_SUFFIX = "max_extra_suffix";
+
// strings under this length will be fully highlighted, instead of showing a snippet of relevant portion
const char *SNIPPET_THRESHOLD = "snippet_threshold";
@@ -708,6 +713,14 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
req_params[SPLIT_JOIN_TOKENS] = "true";
}
+ if(req_params.count(MAX_EXTRA_PREFIX) == 0) {
+ req_params[MAX_EXTRA_PREFIX] = std::to_string(INT16_MAX);
+ }
+
+ if(req_params.count(MAX_EXTRA_SUFFIX) == 0) {
+ req_params[MAX_EXTRA_SUFFIX] = std::to_string(INT16_MAX);
+ }
+
std::vector<std::string> query_by_weights_str;
std::vector<size_t> query_by_weights;
@@ -781,6 +794,14 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
return Option<bool>(400,"Parameter `" + std::string(SEARCH_CUTOFF_MS) + "` must be an unsigned integer.");
}
+ if(!StringUtils::is_uint32_t(req_params[MAX_EXTRA_PREFIX])) {
+ return Option<bool>(400,"Parameter `" + std::string(MAX_EXTRA_PREFIX) + "` must be an unsigned integer.");
+ }
+
+ if(!StringUtils::is_uint32_t(req_params[MAX_EXTRA_SUFFIX])) {
+ return Option<bool>(400,"Parameter `" + std::string(MAX_EXTRA_SUFFIX) + "` must be an unsigned integer.");
+ }
+
bool prioritize_exact_match = (req_params[PRIORITIZE_EXACT_MATCH] == "true");
bool pre_segmented_query = (req_params[PRE_SEGMENTED_QUERY] == "true");
bool exhaustive_search = (req_params[EXHAUSTIVE_SEARCH] == "true");
@@ -833,6 +854,21 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
req_params[MAX_CANDIDATES] = exhaustive_search ? "10000" : "4";
}
+ std::vector<infix_t> infixes;
+ if(req_params.count(INFIX) != 0) {
+ std::vector<std::string> infix_strs;
+ StringUtils::split(req_params[INFIX], infix_strs, ",");
+
+ for(auto& infix_str: infix_strs) {
+ auto infix_op = magic_enum::enum_cast<infix_t>(infix_str);
+ if(infix_op.has_value()) {
+ infixes.push_back(infix_op.value());
+ }
+ }
+ } else {
+ infixes.push_back(off);
+ }
+
bool enable_overrides = (req_params[ENABLE_OVERRIDES] == "true");
CollectionManager & collectionManager = CollectionManager::get_instance();
@@ -898,7 +934,10 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
static_cast<size_t>(std::stol(req_params[MIN_LEN_1TYPO])),
static_cast<size_t>(std::stol(req_params[MIN_LEN_2TYPO])),
split_join_tokens,
- static_cast<size_t>(std::stol(req_params[MAX_CANDIDATES]))
+ static_cast<size_t>(std::stol(req_params[MAX_CANDIDATES])),
+ infixes,
+ static_cast<size_t>(std::stol(req_params[MAX_EXTRA_PREFIX])),
+ static_cast<size_t>(std::stol(req_params[MAX_EXTRA_SUFFIX]))
);
uint64_t timeMillis = std::chrono::duration_cast<std::chrono::milliseconds>(
diff --git a/src/index.cpp b/src/index.cpp
index 825e7ae6..1843d700 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -72,6 +72,16 @@ Index::Index(const std::string& name, const uint32_t collection_id, const Store*
art_tree_init(ft);
search_index.emplace(fname_field.second.faceted_name(), ft);
}
+
+ if(fname_field.second.infix) {
+ array_mapped_infix_t infix_sets(ARRAY_INFIX_DIM);
+
+ for(auto& infix_set: infix_sets) {
+ infix_set = new tsl::htrie_set<char>();
+ }
+
+ infix_index.emplace(fname_field.second.name, infix_sets);
+ }
}
for(const auto & pair: sort_schema) {
@@ -139,6 +149,15 @@ Index::~Index() {
sort_index.clear();
+ for(auto& kv: infix_index) {
+ for(auto& infix_set: kv.second) {
+ delete infix_set;
+ infix_set = nullptr;
+ }
+ }
+
+ infix_index.clear();
+
for(auto& name_tree: str_sort_index) {
delete name_tree.second;
name_tree.second = nullptr;
@@ -660,6 +679,12 @@ void Index::index_field_in_memory(const field& afield, std::vector<index_record>
for(auto &token_offsets: field_index_it->second.offsets) {
token_to_doc_offsets[token_offsets.first].emplace_back(seq_id, record.points, token_offsets.second);
+
+ if(afield.infix) {
+ auto strhash = StringUtils::hash_wy(token_offsets.first.c_str(), token_offsets.first.size());
+ const auto& infix_sets = infix_index.at(afield.name);
+ infix_sets[strhash % 4]->insert(token_offsets.first);
+ }
}
}
@@ -1638,7 +1663,10 @@ void Index::run_search(search_args* search_params) {
search_params->search_cutoff_ms,
search_params->min_len_1typo,
search_params->min_len_2typo,
- search_params->max_candidates);
+ search_params->max_candidates,
+ search_params->infixes,
+ search_params->max_extra_prefix,
+ search_params->max_extra_suffix);
}
void Index::collate_included_ids(const std::vector<std::string>& q_included_tokens,
@@ -2013,6 +2041,59 @@ bool Index::check_for_overrides(const token_ordering& token_order, const string&
return false;
}
+void Index::search_infix(const std::string& query, const std::string& field_name,
+ std::vector<uint32_t>& ids, const size_t max_extra_prefix, const size_t max_extra_suffix) const {
+
+ auto infix_maps_it = infix_index.find(field_name);
+
+ if(infix_maps_it == infix_index.end()) {
+ return ;
+ }
+
+ auto infix_sets = infix_maps_it->second;
+ std::vector<art_leaf*> leaves;
+
+ size_t num_processed = 0;
+ std::mutex m_process;
+ std::condition_variable cv_process;
+
+ auto search_tree = search_index.at(field_name);
+
+ for(auto infix_set: infix_sets) {
+ thread_pool->enqueue([infix_set, &leaves, search_tree, &query, max_extra_prefix, max_extra_suffix,
+ &num_processed, &m_process, &cv_process]() {
+ std::vector<art_leaf*> this_leaves;
+ std::string key_buffer;
+
+ for(auto it = infix_set->begin(); it != infix_set->end(); it++) {
+ it.key(key_buffer);
+ auto start_index = key_buffer.find(query);
+ if(start_index != std::string::npos && start_index <= max_extra_prefix &&
+ (key_buffer.size() - (start_index + query.size())) <= max_extra_suffix) {
+ art_leaf* l = (art_leaf *) art_search(search_tree,
+ (const unsigned char *) key_buffer.c_str(),
+ key_buffer.size()+1);
+ if(l != nullptr) {
+ this_leaves.push_back(l);
+ }
+ }
+ }
+
+ std::unique_lock<std::mutex> lock(m_process);
+ leaves.insert(leaves.end(), this_leaves.begin(), this_leaves.end());
+ num_processed++;
+ cv_process.notify_one();
+ });
+ }
+
+ std::unique_lock<std::mutex> lock_process(m_process);
+ cv_process.wait(lock_process, [&](){ return num_processed == infix_sets.size(); });
+
+ for(auto leaf: leaves) {
+ posting_t::merge({leaf->values}, ids);
+ }
+}
+
void Index::search(std::vector<query_tokens_t>& field_query_tokens,
const std::vector<search_field_t>& search_fields,
std::vector<filter>& filters,
@@ -2040,7 +2121,10 @@ void Index::search(std::vector<query_tokens_t>& field_query_tokens,
const size_t search_cutoff_ms,
size_t min_len_1typo,
size_t min_len_2typo,
- const size_t max_candidates) const {
+ const size_t max_candidates,
+ const std::vector<infix_t>& infixes,
+ const size_t max_extra_prefix,
+ const size_t max_extra_suffix) const {
search_begin = std::chrono::high_resolution_clock::now();
search_stop_ms = search_cutoff_ms;
@@ -2247,6 +2331,7 @@ void Index::search(std::vector<query_tokens_t>& field_query_tokens,
int field_num_typos = (i < num_typos.size()) ? num_typos[i] : num_typos[0];
bool field_prefix = (i < prefixes.size()) ? prefixes[i] : prefixes[0];
+ infix_t field_infix = (i < infixes.size()) ? infixes[i] : infixes[0];
// proceed to query search only when no filters are provided or when filtering produces results
if(filters.empty() || actual_filter_ids_length > 0) {
@@ -2282,6 +2367,34 @@ void Index::search(std::vector<query_tokens_t>& field_query_tokens,
query_hashes, token_order, field_prefix,
drop_tokens_threshold, typo_tokens_threshold, exhaustive_search,
min_len_1typo, min_len_2typo, max_candidates);
+
+ if(field_infix == always || (field_infix == fallback && field_num_results == 0)) {
+ std::vector<uint32_t> infix_ids;
+ search_infix(query_tokens[0].value, field_name, infix_ids, max_extra_prefix, max_extra_suffix);
+ if(!infix_ids.empty()) {
+ int sort_order[3]; // 1 or -1 based on DESC or ASC respectively
+ std::array<spp::sparse_hash_map<uint32_t, int64_t>*, 3> field_values;
+ std::vector<size_t> geopoint_indices;
+ populate_sort_mapping(sort_order, geopoint_indices, sort_fields_std, field_values);
+ uint32_t token_bits = 255;
+
+ for(auto seq_id: infix_ids) {
+ score_results(sort_fields_std, (uint16_t) searched_queries.size(), field_id, false, 2,
+ actual_topster, {}, groups_processed, seq_id, sort_order, field_values,
+ geopoint_indices, group_limit, group_by_fields, token_bits,
+ false, false, {});
+ }
+
+ std::sort(infix_ids.begin(), infix_ids.end());
+ infix_ids.erase(std::unique( infix_ids.begin(), infix_ids.end() ), infix_ids.end());
+
+ uint32_t* new_all_result_ids = nullptr;
+ all_result_ids_len = ArrayUtils::or_scalar(all_result_ids, all_result_ids_len, &infix_ids[0],
+ infix_ids.size(), &new_all_result_ids);
+ delete[] all_result_ids;
+ all_result_ids = new_all_result_ids;
+ }
+ }
} else if(actual_filter_ids_length != 0) {
// indicates exact match query
curate_filtered_ids(filters, curated_ids, exclude_token_ids,
@@ -3708,6 +3821,15 @@ void Index::refresh_schemas(const std::vector<field>& new_fields) {
search_index.emplace(new_field.faceted_name(), ft);
}
}
+
+ if(new_field.infix) {
+ array_mapped_infix_t infix_sets(ARRAY_INFIX_DIM);
+ for(auto& infix_set: infix_sets) {
+ infix_set = new tsl::htrie_set<char>();
+ }
+
+ infix_index.emplace(new_field.name, infix_sets);
+ }
}
}
diff --git a/src/posting_list.cpp b/src/posting_list.cpp
index 7ec3fe08..a1fbdc98 100644
--- a/src/posting_list.cpp
+++ b/src/posting_list.cpp
@@ -581,6 +581,17 @@ void posting_list_t::merge(const std::vector<posting_list_t*>& posting_lists, st
sum_sizes += posting_list->num_ids();
}
+ if(its.size() == 1) {
+ result_ids.reserve(posting_lists[0]->ids_length);
+ auto it = posting_lists[0]->new_iterator();
+ while(it.valid()) {
+ result_ids.push_back(it.id());
+ it.next();
+ }
+
+ return ;
+ }
+
result_ids.reserve(sum_sizes);
size_t num_lists = its.size();
diff --git a/test/collection_infix_search_test.cpp b/test/collection_infix_search_test.cpp
new file mode 100644
index 00000000..14e34110
--- /dev/null
+++ b/test/collection_infix_search_test.cpp
@@ -0,0 +1,222 @@
+#include <gtest/gtest.h>
+#include <string>
+#include <vector>
+#include <fstream>
+#include <algorithm>
+#include <collection_manager.h>
+#include "collection.h"
+
+class CollectionInfixSearchTest : public ::testing::Test {
+protected:
+ Store *store;
+ CollectionManager & collectionManager = CollectionManager::get_instance();
+ std::atomic<bool> quit = false;
+
+ std::vector<std::string> query_fields;
+ std::vector<sort_by> sort_fields;
+
+ void setupCollection() {
+ std::string state_dir_path = "/tmp/typesense_test/collection_infix";
+ LOG(INFO) << "Truncating and creating: " << state_dir_path;
+ system(("rm -rf "+state_dir_path+" && mkdir -p "+state_dir_path).c_str());
+
+ store = new Store(state_dir_path);
+ collectionManager.init(store, 1.0, "auth_key", quit);
+ collectionManager.load(8, 1000);
+ }
+
+ virtual void SetUp() {
+ setupCollection();
+ }
+
+ virtual void TearDown() {
+ collectionManager.dispose();
+ delete store;
+ }
+};
+
+TEST_F(CollectionInfixSearchTest, InfixBasics) {
+ std::vector<field> fields = {field("title", field_types::STRING, false, false, true, "", -1, 1),
+ field("points", field_types::INT32, false),};
+
+ Collection* coll1 = collectionManager.create_collection("coll1", 1, fields, "points").get();
+
+ nlohmann::json doc;
+ doc["id"] = "0";
+ doc["title"] = "GH100037IN8900X";
+ doc["points"] = 100;
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+
+ auto results = coll1->search("100037",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always}).get();
+
+ ASSERT_EQ(1, results["found"].get<size_t>());
+ ASSERT_EQ(1, results["hits"].size());
+ ASSERT_STREQ("0", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+
+ // verify off behavior
+
+ results = coll1->search("100037",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {off}).get();
+
+ ASSERT_EQ(0, results["found"].get<size_t>());
+ ASSERT_EQ(0, results["hits"].size());
+
+ // when fallback is used, only the prefix result is returned
+
+ doc["id"] = "1";
+ doc["title"] = "100037SG7120X";
+ doc["points"] = 100;
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+
+ results = coll1->search("100037",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {fallback}).get();
+
+ ASSERT_EQ(1, results["found"].get<size_t>());
+ ASSERT_EQ(1, results["hits"].size());
+ ASSERT_STREQ("1", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+
+ // always behavior: both prefix and infix matches are returned but ranked below prefix match
+
+ results = coll1->search("100037",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always}).get();
+
+ ASSERT_EQ(2, results["found"].get<size_t>());
+ ASSERT_EQ(2, results["hits"].size());
+ ASSERT_STREQ("1", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+ ASSERT_STREQ("0", results["hits"][1]["document"]["id"].get<std::string>().c_str());
+
+ ASSERT_TRUE(results["hits"][0]["text_match"].get<size_t>() > results["hits"][1]["text_match"].get<size_t>());
+
+ collectionManager.drop_collection("coll1");
+}
+
+TEST_F(CollectionInfixSearchTest, RespectPrefixAndSuffixLimits) {
+ std::vector<field> fields = {field("title", field_types::STRING, false, false, true, "", -1, 1),
+ field("points", field_types::INT32, false),};
+
+ Collection* coll1 = collectionManager.create_collection("coll1", 1, fields, "points").get();
+
+ nlohmann::json doc;
+ doc["id"] = "0";
+ doc["title"] = "GH100037IN8900X";
+ doc["points"] = 100;
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+
+ doc["id"] = "1";
+ doc["title"] = "X100037SG89007120X";
+ doc["points"] = 100;
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+
+ // check extra prefixes
+
+ auto results = coll1->search("100037",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always}, 1).get();
+
+ ASSERT_EQ(1, results["found"].get<size_t>());
+ ASSERT_EQ(1, results["hits"].size());
+ ASSERT_STREQ("1", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+
+ results = coll1->search("100037",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always}, 2).get();
+
+ ASSERT_EQ(2, results["found"].get<size_t>());
+ ASSERT_EQ(2, results["hits"].size());
+ ASSERT_STREQ("1", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+ ASSERT_STREQ("0", results["hits"][1]["document"]["id"].get<std::string>().c_str());
+
+ // check extra suffixes
+ results = coll1->search("8900",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always}, INT16_MAX, 2).get();
+
+ ASSERT_EQ(1, results["found"].get<size_t>());
+ ASSERT_EQ(1, results["hits"].size());
+ ASSERT_STREQ("0", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+
+ results = coll1->search("8900",
+ {"title"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always}, INT16_MAX, 5).get();
+
+ ASSERT_EQ(2, results["found"].get<size_t>());
+ ASSERT_EQ(2, results["hits"].size());
+ ASSERT_STREQ("1", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+ ASSERT_STREQ("0", results["hits"][1]["document"]["id"].get<std::string>().c_str());
+
+ collectionManager.drop_collection("coll1");
+}
+
+TEST_F(CollectionInfixSearchTest, InfixSpecificField) {
+ std::vector<field> fields = {field("title", field_types::STRING, false, false, true, "", -1, 1),
+ field("description", field_types::STRING, false, false, true, "", -1, 1),
+ field("points", field_types::INT32, false),};
+
+ Collection* coll1 = collectionManager.create_collection("coll1", 1, fields, "points").get();
+
+ nlohmann::json doc;
+ doc["id"] = "0";
+ doc["title"] = "GH100037IN8900X";
+ doc["description"] = "foobar";
+ doc["points"] = 100;
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+
+ doc["id"] = "1";
+ doc["title"] = "foobar";
+ doc["description"] = "GH100037IN8900X";
+ doc["points"] = 100;
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+
+ auto results = coll1->search("100037",
+ {"title", "description"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {always, off}).get();
+
+ ASSERT_EQ(1, results["found"].get<size_t>());
+ ASSERT_EQ(1, results["hits"].size());
+ ASSERT_STREQ("0", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+
+ results = coll1->search("100037",
+ {"title", "description"}, "", {}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "title", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, true,
+ 4, {off, always}).get();
+
+ ASSERT_EQ(1, results["found"].get<size_t>());
+ ASSERT_EQ(1, results["hits"].size());
+ ASSERT_STREQ("1", results["hits"][0]["document"]["id"].get<std::string>().c_str());
+
+ collectionManager.drop_collection("coll1");
+}