Fix typos.

Author: Tessil

README.md

@@ -30,8 +30,8 @@ A **benchmark** of `tsl::array_map` against other hash maps can be found [here](
 `tsl::array_map` tries to have an interface similar to `std::unordered_map`, but some differences exist:
 - Iterator invalidation doesn't behave in the same way, any operation modifying the hash table invalidate them (see [API](https://tessil.github.io/array-hash/doc/html/classtsl_1_1array__map.html#details) for details).
 - References and pointers to keys or values in the map are invalidated in the same way as iterators to these keys-values.
-- Erase operations have an amortized runtime complexity of O(1) for `tsl::array_map`. An erase operation will delete the key immediatly but for the value part of the map, the deletion may be delayed. The destructor of the value is only called 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. The method `shrink_to_fit` may be called to force the deletion.
-- The key and the value are stored separatly and not in a `std::pair<const Key, T>`. Methods like `insert` or `emplace` take the key and the value separatly instead of a `std::pair`. The insert method looks like `std::pair<iterator, bool> insert(const CharT* key, const T& value)` instead of `std::pair<iterator, bool> insert(const std::pair<const Key, T>& value)` (see [API](https://tessil.github.io/array-hash/doc/html/classtsl_1_1array__map.html) for details).
+- Erase operations have an amortized runtime complexity of O(1) for `tsl::array_map`. An erase operation will delete the key immediately but for the value part of the map, the deletion may be delayed. The destructor of the value is only called 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. The method `shrink_to_fit` may be called to force the deletion.
+- The key and the value are stored separately and not in a `std::pair<const Key, T>`. Methods like `insert` or `emplace` take the key and the value separately instead of a `std::pair`. The insert method looks like `std::pair<iterator, bool> insert(const CharT* key, const T& value)` instead of `std::pair<iterator, bool> insert(const std::pair<const Key, T>& value)` (see [API](https://tessil.github.io/array-hash/doc/html/classtsl_1_1array__map.html) for details).
 - For iterators, `operator*()` and `operator->()` return a reference and a pointer to the value `T` instead of `std::pair<const Key, T>`. For an access to the key string, the `key()` (which returns a `const CharT*`) or `key_sv()` (which returns a `std::basic_string_view<CharT>`) method of the iterator must be called.
 - No support for some bucket related methods (like `bucket_size`, `bucket`, ...).
 
@@ -211,7 +211,7 @@ struct deserializer {
 };
 ```
 
-Note that the implementation leaves binary compatibilty (endianness, float binary representation, size of int, ...) of the types it serializes/deserializes in the hands of the provided function objects if compatibilty is required.
+Note that the implementation leaves binary compatibility (endianness, float binary representation, size of int, ...) of the types it serializes/deserializes in the hands of the provided function objects if compatibility is required.
 
 More details regarding the `serialize` and `deserialize` methods can be found in the [API](https://tessil.github.io/array-hash/doc/html/classtsl_1_1array__map.html).
 

include/tsl/array_growth_policy.h

@@ -58,7 +58,7 @@ class power_of_two_growth_policy {
      */
     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 maxmimum size.");
+            throw std::length_error("The hash table exceeds its maximum size.");
         }
 
         if(min_bucket_count_in_out > 0) {
@@ -83,7 +83,7 @@ class power_of_two_growth_policy {
      */
     std::size_t next_bucket_count() const {
         if((m_mask + 1) > max_bucket_count() / GrowthFactor) {
-            throw std::length_error("The hash table exceeds its maxmimum size.");
+            throw std::length_error("The hash table exceeds its maximum size.");
         }
 
         return (m_mask + 1) * GrowthFactor;
@@ -143,7 +143,7 @@ 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 maxmimum size.");
+            throw std::length_error("The hash table exceeds its maximum size.");
         }
 
         if(min_bucket_count_in_out > 0) {
@@ -160,12 +160,12 @@ class mod_growth_policy {
 
     std::size_t next_bucket_count() const {
         if(m_mod == max_bucket_count()) {
-            throw std::length_error("The hash table exceeds its maxmimum size.");
+            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 maxmimum size.");
+            throw std::length_error("The hash table exceeds its maximum size.");
         }
 
         if(next_bucket_count > double(max_bucket_count())) {
@@ -265,15 +265,15 @@ static constexpr const std::array<std::size_t(*)(std::size_t), TSL_AH_NB_PRIMES>
  * 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 environement.
+ * 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 maxmimum size.");
+            throw std::length_error("The hash table exceeds its maximum size.");
         }
 
         m_iprime = static_cast<unsigned int>(std::distance(detail::PRIMES.begin(), it_prime));
@@ -291,7 +291,7 @@ class prime_growth_policy {
 
     std::size_t next_bucket_count() const {
         if(m_iprime + 1 >= detail::PRIMES.size()) {
-            throw std::length_error("The hash table exceeds its maxmimum size.");
+            throw std::length_error("The hash table exceeds its maximum size.");
         }
 
         return detail::PRIMES[m_iprime + 1];

include/tsl/array_hash.h

@@ -434,7 +434,7 @@ class array_bucket {
     /**
      * 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 intiailized yet. You usually get this value from find_or_end_of_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.
      */
@@ -716,7 +716,7 @@ class value_container {
 protected:
     static constexpr float VECTOR_GROWTH_RATE = 1.5f;
 
-    // TODO use a sparse array? or a std::dequeu
+    // TODO use a sparse array? or a std::deque
     std::vector<T> m_values;
 };
 
@@ -927,7 +927,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
                                        Hash(hash), 
                                        GrowthPolicy(bucket_count), 
                                        m_buckets_data(bucket_count > max_bucket_count()?
-                                                      throw std::length_error("The map exceeds its maxmimum 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) 
@@ -1102,7 +1102,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
 
 
     iterator erase(const_iterator pos) {
-        if(shoud_clear_old_erased_values()) {
+        if(should_clear_old_erased_values()) {
             clear_old_erased_values();
         }
 
@@ -1134,7 +1134,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
             nb_elements_until_last--;
         }
 
-        if(shoud_clear_old_erased_values()) {
+        if(should_clear_old_erased_values()) {
             clear_old_erased_values();
         }
 
@@ -1148,7 +1148,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
     }
 
     size_type erase(const CharT* key, size_type key_size, std::size_t hash) {
-        if(shoud_clear_old_erased_values()) {
+        if(should_clear_old_erased_values()) {
             clear_old_erased_values();
         }
 
@@ -1411,12 +1411,12 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
 
 
     template<class U = T, typename std::enable_if<!has_mapped_type<U>::value>::type* = nullptr>
-    bool shoud_clear_old_erased_values(float /*threshold*/ = DEFAULT_CLEAR_OLD_ERASED_VALUE_THRESHOLD) const {
+    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 shoud_clear_old_erased_values(float threshold = DEFAULT_CLEAR_OLD_ERASED_VALUE_THRESHOLD) const {
+    bool should_clear_old_erased_values(float threshold = DEFAULT_CLEAR_OLD_ERASED_VALUE_THRESHOLD) const {
         if(this->m_values.size() == 0) {
             return false;
         }
@@ -1458,7 +1458,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
     }
 
     /**
-     * Return true if a rehash occured.
+     * Return true if a rehash occurred.
      */
     bool grow_on_high_load() {
         if(size() >= m_load_threshold) {
@@ -1521,7 +1521,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
         }
 
 
-        if(shoud_clear_old_erased_values(REHASH_CLEAR_OLD_ERASED_VALUE_THRESHOLD)) {
+        if(should_clear_old_erased_values(REHASH_CLEAR_OLD_ERASED_VALUE_THRESHOLD)) {
             clear_old_erased_values();
         }
 
@@ -1688,7 +1688,7 @@ class array_hash: private value_container<T>, private Hash, private GrowthPolicy
 
 
         if(load_factor() > this->max_load_factor()) {
-            throw std::runtime_error("Invalid max_load_factor. Check that the serializer and deserializer supports "
+            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.");
         }
     }

include/tsl/array_map.h

@@ -44,7 +44,7 @@ namespace tsl {
  * 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-constuctible or both.
+ * 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. 
@@ -294,7 +294,7 @@ class array_map {
 
 
     /**
-     * Erase has an amortized O(1) runtime complexity, but even if it removes the key immediatly,
+     * 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 
@@ -368,7 +368,7 @@ class array_map {
      * @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). Usefull to speed-up the lookup to the value if you already have the hash.
+     * 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);
@@ -463,7 +463,7 @@ class array_map {
 #endif  
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
-     * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
+     * 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); 
@@ -530,7 +530,7 @@ class array_map {
 #endif
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
-     * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
+     * 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); 
@@ -618,7 +618,7 @@ class array_map {
 #endif    
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
-     * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
+     * 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);
@@ -713,7 +713,7 @@ class array_map {
 #endif    
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
-     * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
+     * 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);
@@ -768,16 +768,16 @@ class array_map {
      *  - `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 compatibilty (endianness, IEEE 754 for floats, ...) of the types it serializes
-     * in the hands of the `Serializer` function object if compatibilty is required.
+     * 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 previouly serialized map through the `deserializer` parameter.
+     * 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.
@@ -791,8 +791,8 @@ class array_map {
      * 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 compatibilty (endianness, IEEE 754 for floats, size of int, ...) of the types it 
-     * deserializes in the hands of the `Deserializer` function object if compatibilty is required.
+     * 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) {