2018-05-30 01:28:48 +02:00
|
|
|
/*
|
2018-05-30 02:58:46 +02:00
|
|
|
* Copyright © 2018 Google, Inc.
|
2018-05-30 01:28:48 +02:00
|
|
|
*
|
|
|
|
* This is part of HarfBuzz, a text shaping library.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, without written agreement and without
|
|
|
|
* license or royalty fees, to use, copy, modify, and distribute this
|
|
|
|
* software and its documentation for any purpose, provided that the
|
|
|
|
* above copyright notice and the following two paragraphs appear in
|
|
|
|
* all copies of this software.
|
|
|
|
*
|
|
|
|
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
|
|
|
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
|
|
|
|
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
|
|
|
* DAMAGE.
|
|
|
|
*
|
|
|
|
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
|
|
|
|
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
|
|
|
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
|
|
|
|
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|
|
|
*
|
|
|
|
* Google Author(s): Behdad Esfahbod
|
|
|
|
*/
|
|
|
|
|
2018-08-26 07:36:36 +02:00
|
|
|
#ifndef HB_MAP_HH
|
|
|
|
#define HB_MAP_HH
|
2018-05-30 01:28:48 +02:00
|
|
|
|
2018-08-26 07:36:36 +02:00
|
|
|
#include "hb.hh"
|
2018-05-30 01:28:48 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
2019-03-30 22:30:22 +01:00
|
|
|
* hb_hashmap_t
|
2018-05-30 01:28:48 +02:00
|
|
|
*/
|
|
|
|
|
2022-06-27 21:29:22 +02:00
|
|
|
extern HB_INTERNAL const hb_codepoint_t minus_1;
|
|
|
|
|
2019-03-30 22:30:22 +01:00
|
|
|
template <typename K, typename V,
|
2022-06-02 19:11:35 +02:00
|
|
|
bool minus_one = false>
|
2019-03-30 22:30:22 +01:00
|
|
|
struct hb_hashmap_t
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2019-03-30 22:30:22 +01:00
|
|
|
hb_hashmap_t () { init (); }
|
|
|
|
~hb_hashmap_t () { fini (); }
|
|
|
|
|
2022-05-18 20:17:43 +02:00
|
|
|
hb_hashmap_t (const hb_hashmap_t& o) : hb_hashmap_t () { resize (population); hb_copy (o, *this); }
|
2021-11-02 05:29:14 +01:00
|
|
|
hb_hashmap_t (hb_hashmap_t&& o) : hb_hashmap_t () { hb_swap (*this, o); }
|
2022-05-18 20:17:43 +02:00
|
|
|
hb_hashmap_t& operator= (const hb_hashmap_t& o) { resize (population); hb_copy (o, *this); return *this; }
|
2021-11-02 05:29:14 +01:00
|
|
|
hb_hashmap_t& operator= (hb_hashmap_t&& o) { hb_swap (*this, o); return *this; }
|
|
|
|
|
2021-11-02 05:45:11 +01:00
|
|
|
hb_hashmap_t (std::initializer_list<hb_pair_t<K, V>> lst) : hb_hashmap_t ()
|
|
|
|
{
|
|
|
|
for (auto&& item : lst)
|
|
|
|
set (item.first, item.second);
|
|
|
|
}
|
2021-11-02 05:47:26 +01:00
|
|
|
template <typename Iterable,
|
|
|
|
hb_requires (hb_is_iterable (Iterable))>
|
|
|
|
hb_hashmap_t (const Iterable &o) : hb_hashmap_t ()
|
|
|
|
{
|
2022-05-18 20:17:43 +02:00
|
|
|
auto iter = hb_iter (o);
|
|
|
|
if (iter.is_random_access_iterator)
|
|
|
|
resize (hb_len (iter));
|
|
|
|
hb_copy (iter, *this);
|
2021-11-02 05:47:26 +01:00
|
|
|
}
|
2021-11-02 05:45:11 +01:00
|
|
|
|
2018-05-30 01:28:48 +02:00
|
|
|
struct item_t
|
|
|
|
{
|
2019-03-30 22:30:22 +01:00
|
|
|
K key;
|
2022-06-02 18:32:56 +02:00
|
|
|
uint32_t hash : 30;
|
|
|
|
uint32_t is_used_ : 1;
|
|
|
|
uint32_t is_tombstone_ : 1;
|
2022-05-26 19:31:28 +02:00
|
|
|
V value;
|
2018-05-30 01:28:48 +02:00
|
|
|
|
2022-06-02 18:13:55 +02:00
|
|
|
bool is_used () const { return is_used_; }
|
|
|
|
void set_used (bool is_used) { is_used_ = is_used; }
|
|
|
|
bool is_tombstone () const { return is_tombstone_; }
|
|
|
|
void set_tombstone (bool is_tombstone) { is_tombstone_ = is_tombstone; }
|
|
|
|
bool is_real () const { return is_used_ && !is_tombstone_; }
|
|
|
|
|
2022-06-02 19:11:35 +02:00
|
|
|
template <bool v = minus_one,
|
|
|
|
hb_enable_if (v == false)>
|
2022-06-27 21:17:10 +02:00
|
|
|
static inline const V& default_value () { return Null(V); };
|
2022-06-02 19:11:35 +02:00
|
|
|
template <bool v = minus_one,
|
|
|
|
hb_enable_if (v == true)>
|
2022-06-27 21:29:22 +02:00
|
|
|
static inline const V& default_value ()
|
|
|
|
{
|
|
|
|
static_assert (hb_is_same (V, hb_codepoint_t), "");
|
|
|
|
return minus_1;
|
|
|
|
};
|
2022-06-02 19:11:35 +02:00
|
|
|
|
2022-01-13 20:38:26 +01:00
|
|
|
void clear ()
|
|
|
|
{
|
2022-01-14 00:17:34 +01:00
|
|
|
new (std::addressof (key)) K ();
|
|
|
|
new (std::addressof (value)) V ();
|
2022-01-13 20:38:26 +01:00
|
|
|
hash = 0;
|
2022-06-02 18:13:55 +02:00
|
|
|
is_used_ = false;
|
|
|
|
is_tombstone_ = false;
|
2022-01-13 20:38:26 +01:00
|
|
|
}
|
2019-04-03 04:27:02 +02:00
|
|
|
|
2020-07-09 01:17:40 +02:00
|
|
|
bool operator == (const K &o) { return hb_deref (key) == hb_deref (o); }
|
2019-04-03 04:27:02 +02:00
|
|
|
bool operator == (const item_t &o) { return *this == o.key; }
|
2019-05-08 21:09:10 +02:00
|
|
|
hb_pair_t<K, V> get_pair() const { return hb_pair_t<K, V> (key, value); }
|
2022-06-03 09:30:27 +02:00
|
|
|
hb_pair_t<const K &, const V &> get_pair_ref() const { return hb_pair_t<const K &, const V &> (key, value); }
|
2022-05-26 19:20:27 +02:00
|
|
|
|
|
|
|
uint32_t total_hash () const
|
|
|
|
{ return (hash * 31) + hb_hash (value); }
|
2018-05-30 01:28:48 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
hb_object_header_t header;
|
2018-06-01 05:03:00 +02:00
|
|
|
bool successful; /* Allocations successful */
|
2018-05-30 02:00:02 +02:00
|
|
|
unsigned int population; /* Not including tombstones. */
|
2018-05-30 01:28:48 +02:00
|
|
|
unsigned int occupancy; /* Including tombstones. */
|
|
|
|
unsigned int mask;
|
|
|
|
unsigned int prime;
|
|
|
|
item_t *items;
|
|
|
|
|
2021-11-02 05:29:14 +01:00
|
|
|
friend void swap (hb_hashmap_t& a, hb_hashmap_t& b)
|
|
|
|
{
|
|
|
|
if (unlikely (!a.successful || !b.successful))
|
|
|
|
return;
|
|
|
|
hb_swap (a.population, b.population);
|
|
|
|
hb_swap (a.occupancy, b.occupancy);
|
|
|
|
hb_swap (a.mask, b.mask);
|
|
|
|
hb_swap (a.prime, b.prime);
|
|
|
|
hb_swap (a.items, b.items);
|
|
|
|
}
|
2022-07-20 23:57:09 +02:00
|
|
|
void init ()
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2022-07-20 23:57:09 +02:00
|
|
|
hb_object_init (this);
|
|
|
|
|
2018-06-01 05:03:00 +02:00
|
|
|
successful = true;
|
2018-05-30 02:09:17 +02:00
|
|
|
population = occupancy = 0;
|
2018-05-30 01:28:48 +02:00
|
|
|
mask = 0;
|
|
|
|
prime = 0;
|
|
|
|
items = nullptr;
|
|
|
|
}
|
2022-07-20 23:57:09 +02:00
|
|
|
void fini ()
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2022-07-20 23:57:09 +02:00
|
|
|
hb_object_fini (this);
|
|
|
|
|
2022-01-15 01:20:31 +01:00
|
|
|
if (likely (items)) {
|
2022-01-15 01:20:31 +01:00
|
|
|
unsigned size = mask + 1;
|
|
|
|
for (unsigned i = 0; i < size; i++)
|
|
|
|
items[i].~item_t ();
|
|
|
|
hb_free (items);
|
|
|
|
items = nullptr;
|
|
|
|
}
|
2019-03-31 03:44:01 +02:00
|
|
|
population = occupancy = 0;
|
2018-05-30 01:28:48 +02:00
|
|
|
}
|
|
|
|
|
2019-03-31 01:51:26 +01:00
|
|
|
void reset ()
|
|
|
|
{
|
2019-04-03 05:13:16 +02:00
|
|
|
successful = true;
|
2019-04-03 04:27:02 +02:00
|
|
|
clear ();
|
2019-03-31 01:51:26 +01:00
|
|
|
}
|
|
|
|
|
2018-12-18 19:22:17 +01:00
|
|
|
bool in_error () const { return !successful; }
|
|
|
|
|
2022-05-18 20:17:43 +02:00
|
|
|
bool resize (unsigned new_population = 0)
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2018-06-01 05:03:00 +02:00
|
|
|
if (unlikely (!successful)) return false;
|
2018-05-30 01:28:48 +02:00
|
|
|
|
2022-05-18 20:17:43 +02:00
|
|
|
unsigned int power = hb_bit_storage (hb_max (population, new_population) * 2 + 8);
|
2018-05-30 01:28:48 +02:00
|
|
|
unsigned int new_size = 1u << power;
|
2021-07-08 18:58:50 +02:00
|
|
|
item_t *new_items = (item_t *) hb_malloc ((size_t) new_size * sizeof (item_t));
|
2018-05-30 01:28:48 +02:00
|
|
|
if (unlikely (!new_items))
|
|
|
|
{
|
2018-06-01 05:03:00 +02:00
|
|
|
successful = false;
|
2018-05-30 01:28:48 +02:00
|
|
|
return false;
|
|
|
|
}
|
2020-06-21 07:19:48 +02:00
|
|
|
for (auto &_ : hb_iter (new_items, new_size))
|
|
|
|
_.clear ();
|
2018-05-30 01:28:48 +02:00
|
|
|
|
|
|
|
unsigned int old_size = mask + 1;
|
|
|
|
item_t *old_items = items;
|
|
|
|
|
|
|
|
/* Switch to new, empty, array. */
|
2018-05-30 02:09:17 +02:00
|
|
|
population = occupancy = 0;
|
2018-05-30 01:28:48 +02:00
|
|
|
mask = new_size - 1;
|
2018-06-06 23:55:30 +02:00
|
|
|
prime = prime_for (power);
|
2018-05-30 01:28:48 +02:00
|
|
|
items = new_items;
|
|
|
|
|
|
|
|
/* Insert back old items. */
|
2018-05-30 03:32:57 +02:00
|
|
|
if (old_items)
|
|
|
|
for (unsigned int i = 0; i < old_size; i++)
|
2022-01-13 23:06:58 +01:00
|
|
|
{
|
2019-04-03 05:17:27 +02:00
|
|
|
if (old_items[i].is_real ())
|
2022-01-13 23:06:58 +01:00
|
|
|
{
|
2019-10-22 20:55:04 +02:00
|
|
|
set_with_hash (old_items[i].key,
|
2020-04-20 11:42:45 +02:00
|
|
|
old_items[i].hash,
|
2021-11-02 07:14:34 +01:00
|
|
|
std::move (old_items[i].value));
|
2022-01-13 23:06:58 +01:00
|
|
|
}
|
|
|
|
old_items[i].~item_t ();
|
|
|
|
}
|
2018-05-30 01:28:48 +02:00
|
|
|
|
2021-07-08 18:58:50 +02:00
|
|
|
hb_free (old_items);
|
2018-05-30 01:28:48 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-06-03 02:04:12 +02:00
|
|
|
template <typename VV>
|
|
|
|
bool set (K key, VV&& value) { return set_with_hash (key, hb_hash (key), std::forward<VV> (value)); }
|
2019-10-22 20:55:04 +02:00
|
|
|
|
2022-06-03 02:04:12 +02:00
|
|
|
const V& get (K key) const
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2022-06-02 19:11:35 +02:00
|
|
|
if (unlikely (!items)) return item_t::default_value ();
|
2018-05-30 01:28:48 +02:00
|
|
|
unsigned int i = bucket_for (key);
|
2022-06-02 19:11:35 +02:00
|
|
|
return items[i].is_real () && items[i] == key ? items[i].value : item_t::default_value ();
|
2018-05-30 01:28:48 +02:00
|
|
|
}
|
|
|
|
|
2022-06-02 19:11:35 +02:00
|
|
|
void del (K key) { set_with_hash (key, hb_hash (key), item_t::default_value (), true); }
|
2018-05-30 01:28:48 +02:00
|
|
|
|
2019-01-28 22:34:04 +01:00
|
|
|
/* Has interface. */
|
2022-06-27 21:31:05 +02:00
|
|
|
typedef const V& value_t;
|
2019-03-30 22:30:22 +01:00
|
|
|
value_t operator [] (K k) const { return get (k); }
|
2022-07-20 22:43:58 +02:00
|
|
|
template <typename VV=V>
|
|
|
|
bool has (K key, VV **vp = nullptr) const
|
2019-05-08 21:11:52 +02:00
|
|
|
{
|
2022-06-02 19:18:38 +02:00
|
|
|
if (unlikely (!items))
|
|
|
|
return false;
|
|
|
|
unsigned int i = bucket_for (key);
|
|
|
|
if (items[i].is_real () && items[i] == key)
|
|
|
|
{
|
2022-06-03 02:04:12 +02:00
|
|
|
if (vp) *vp = &items[i].value;
|
2022-06-02 19:18:38 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
2019-05-08 21:11:52 +02:00
|
|
|
}
|
2019-01-28 22:34:04 +01:00
|
|
|
/* Projection. */
|
2019-03-30 22:30:22 +01:00
|
|
|
V operator () (K k) const { return get (k); }
|
2019-01-09 17:39:25 +01:00
|
|
|
|
2018-12-17 19:01:01 +01:00
|
|
|
void clear ()
|
2018-05-30 02:09:17 +02:00
|
|
|
{
|
2021-08-24 18:31:49 +02:00
|
|
|
if (unlikely (!successful)) return;
|
|
|
|
|
2019-04-03 04:27:02 +02:00
|
|
|
if (items)
|
2020-06-21 07:19:48 +02:00
|
|
|
for (auto &_ : hb_iter (items, mask + 1))
|
|
|
|
_.clear ();
|
2019-04-03 04:27:02 +02:00
|
|
|
|
2018-05-30 02:09:17 +02:00
|
|
|
population = occupancy = 0;
|
|
|
|
}
|
|
|
|
|
2018-12-17 19:01:01 +01:00
|
|
|
bool is_empty () const { return population == 0; }
|
2020-06-29 07:41:09 +02:00
|
|
|
explicit operator bool () const { return !is_empty (); }
|
2018-05-30 02:09:17 +02:00
|
|
|
|
2022-05-19 23:42:54 +02:00
|
|
|
uint32_t hash () const
|
2022-05-19 21:38:52 +02:00
|
|
|
{
|
2022-05-19 23:42:54 +02:00
|
|
|
uint32_t h = 0;
|
2022-05-26 19:20:27 +02:00
|
|
|
for (const auto &item : + hb_array (items, mask ? mask + 1 : 0)
|
|
|
|
| hb_filter (&item_t::is_real))
|
|
|
|
h ^= item.total_hash ();
|
2022-05-19 21:38:52 +02:00
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2022-05-19 21:36:12 +02:00
|
|
|
bool is_equal (const hb_hashmap_t &other) const
|
|
|
|
{
|
|
|
|
if (population != other.population) return false;
|
|
|
|
|
|
|
|
for (auto pair : iter ())
|
|
|
|
if (get (pair.first) != pair.second)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool operator == (const hb_hashmap_t &other) const { return is_equal (other); }
|
|
|
|
bool operator != (const hb_hashmap_t &other) const { return !is_equal (other); }
|
|
|
|
|
2018-12-17 19:01:01 +01:00
|
|
|
unsigned int get_population () const { return population; }
|
2018-05-30 02:09:17 +02:00
|
|
|
|
2019-05-08 20:40:31 +02:00
|
|
|
/*
|
|
|
|
* Iterator
|
|
|
|
*/
|
2019-05-08 23:46:55 +02:00
|
|
|
auto iter () const HB_AUTO_RETURN
|
2019-05-08 20:40:31 +02:00
|
|
|
(
|
2019-05-09 00:05:10 +02:00
|
|
|
+ hb_array (items, mask ? mask + 1 : 0)
|
2019-05-08 20:40:31 +02:00
|
|
|
| hb_filter (&item_t::is_real)
|
|
|
|
| hb_map (&item_t::get_pair)
|
|
|
|
)
|
2022-06-03 09:11:22 +02:00
|
|
|
auto iter_ref () const HB_AUTO_RETURN
|
|
|
|
(
|
|
|
|
+ hb_array (items, mask ? mask + 1 : 0)
|
|
|
|
| hb_filter (&item_t::is_real)
|
2022-06-03 09:30:27 +02:00
|
|
|
| hb_map (&item_t::get_pair_ref)
|
2022-06-03 09:11:22 +02:00
|
|
|
)
|
2019-05-08 23:46:55 +02:00
|
|
|
auto keys () const HB_AUTO_RETURN
|
2019-05-08 21:47:18 +02:00
|
|
|
(
|
[map] Fix bots
Older compilers don't like calling iter() from return-type decltype()
../src/hb-map.hh:226:12: error: cannot call member function 'decltype ((((+ hb_array(((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::items, (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask ? (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask + 1) : 0))) | hb_filter((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: is_real))) | hb_map((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: get_pair)))) hb_hashmap_t<K, V, kINVALID, vINVALID>::iter() const [with K = const hb_serialize_context_t::object_t*; V = unsigned int; K kINVALID = 0u; V vINVALID = 0u; decltype ((((+ hb_array(((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::items, (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask ? (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask + 1) : 0))) | hb_filter((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: is_real))) | hb_map((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: get_pair)))) = hb_map_iter_t<hb_filter_iter_t<hb_array_t<hb_hashmap_t<const hb_serialize_context_t::object_t*, unsigned int, 0u, 0u>::item_t>, bool (hb_hashmap_t<const hb_serialize_context_t::object_t*, unsigned int, 0u, 0u>::item_t::*)() const, const<anonymous struct>&, 0u>, hb_pair_t<const hb_serialize_context_t::object_t*, unsigned int> (hb_hashmap_t<const hb_serialize_context_t::object_t*, unsigned int, 0u, 0u>::item_t::*)() const, 0u>]' without object
+ iter()
^
../src/hb-meta.hh:58:41: note: in definition of macro 'HB_AUTO_RETURN'
#define HB_AUTO_RETURN(E) -> decltype ((E)) { return (E); }
^
2019-05-09 00:28:39 +02:00
|
|
|
+ hb_array (items, mask ? mask + 1 : 0)
|
|
|
|
| hb_filter (&item_t::is_real)
|
|
|
|
| hb_map (&item_t::key)
|
2019-05-09 21:43:57 +02:00
|
|
|
| hb_map (hb_ridentity)
|
2019-05-08 21:47:18 +02:00
|
|
|
)
|
2022-07-12 21:19:31 +02:00
|
|
|
auto keys_ref () const HB_AUTO_RETURN
|
|
|
|
(
|
|
|
|
+ hb_array (items, mask ? mask + 1 : 0)
|
|
|
|
| hb_filter (&item_t::is_real)
|
|
|
|
| hb_map (&item_t::key)
|
|
|
|
)
|
2019-05-09 00:08:10 +02:00
|
|
|
auto values () const HB_AUTO_RETURN
|
|
|
|
(
|
[map] Fix bots
Older compilers don't like calling iter() from return-type decltype()
../src/hb-map.hh:226:12: error: cannot call member function 'decltype ((((+ hb_array(((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::items, (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask ? (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask + 1) : 0))) | hb_filter((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: is_real))) | hb_map((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: get_pair)))) hb_hashmap_t<K, V, kINVALID, vINVALID>::iter() const [with K = const hb_serialize_context_t::object_t*; V = unsigned int; K kINVALID = 0u; V vINVALID = 0u; decltype ((((+ hb_array(((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::items, (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask ? (((const hb_hashmap_t<K, V, kINVALID, vINVALID>*)this)->hb_hashmap_t<K, V, kINVALID, vINVALID>::mask + 1) : 0))) | hb_filter((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: is_real))) | hb_map((& hb_hashmap_t<K, V, kINVALID, vINVALID>::item_t:: get_pair)))) = hb_map_iter_t<hb_filter_iter_t<hb_array_t<hb_hashmap_t<const hb_serialize_context_t::object_t*, unsigned int, 0u, 0u>::item_t>, bool (hb_hashmap_t<const hb_serialize_context_t::object_t*, unsigned int, 0u, 0u>::item_t::*)() const, const<anonymous struct>&, 0u>, hb_pair_t<const hb_serialize_context_t::object_t*, unsigned int> (hb_hashmap_t<const hb_serialize_context_t::object_t*, unsigned int, 0u, 0u>::item_t::*)() const, 0u>]' without object
+ iter()
^
../src/hb-meta.hh:58:41: note: in definition of macro 'HB_AUTO_RETURN'
#define HB_AUTO_RETURN(E) -> decltype ((E)) { return (E); }
^
2019-05-09 00:28:39 +02:00
|
|
|
+ hb_array (items, mask ? mask + 1 : 0)
|
|
|
|
| hb_filter (&item_t::is_real)
|
|
|
|
| hb_map (&item_t::value)
|
2019-05-09 21:43:57 +02:00
|
|
|
| hb_map (hb_ridentity)
|
2019-05-09 00:08:10 +02:00
|
|
|
)
|
2022-07-12 21:19:31 +02:00
|
|
|
auto values_ref () const HB_AUTO_RETURN
|
|
|
|
(
|
|
|
|
+ hb_array (items, mask ? mask + 1 : 0)
|
|
|
|
| hb_filter (&item_t::is_real)
|
|
|
|
| hb_map (&item_t::value)
|
|
|
|
)
|
2019-05-08 21:47:18 +02:00
|
|
|
|
2019-05-09 01:31:52 +02:00
|
|
|
/* Sink interface. */
|
2020-04-23 19:50:02 +02:00
|
|
|
hb_hashmap_t& operator << (const hb_pair_t<K, V>& v)
|
2019-05-09 01:31:52 +02:00
|
|
|
{ set (v.first, v.second); return *this; }
|
|
|
|
|
2018-05-30 01:28:48 +02:00
|
|
|
protected:
|
|
|
|
|
2021-11-02 06:13:34 +01:00
|
|
|
template <typename VV>
|
2022-06-02 18:13:55 +02:00
|
|
|
bool set_with_hash (K key, uint32_t hash, VV&& value, bool is_delete=false)
|
2019-10-22 20:55:04 +02:00
|
|
|
{
|
2021-03-30 02:12:05 +02:00
|
|
|
if (unlikely (!successful)) return false;
|
|
|
|
if (unlikely ((occupancy + occupancy / 2) >= mask && !resize ())) return false;
|
2019-10-22 20:55:04 +02:00
|
|
|
unsigned int i = bucket_for_hash (key, hash);
|
|
|
|
|
2022-06-02 18:13:55 +02:00
|
|
|
if (is_delete && items[i].key != key)
|
2021-03-30 02:12:05 +02:00
|
|
|
return true; /* Trying to delete non-existent key. */
|
2019-10-22 20:55:04 +02:00
|
|
|
|
2022-06-02 18:13:55 +02:00
|
|
|
if (items[i].is_used ())
|
2019-10-22 20:55:04 +02:00
|
|
|
{
|
|
|
|
occupancy--;
|
2021-08-10 21:29:32 +02:00
|
|
|
if (!items[i].is_tombstone ())
|
2019-10-22 20:55:04 +02:00
|
|
|
population--;
|
|
|
|
}
|
|
|
|
|
|
|
|
items[i].key = key;
|
2022-06-03 02:04:12 +02:00
|
|
|
items[i].value = std::forward<VV> (value);
|
2019-10-22 20:55:04 +02:00
|
|
|
items[i].hash = hash;
|
2022-06-02 18:13:55 +02:00
|
|
|
items[i].set_used (true);
|
|
|
|
items[i].set_tombstone (is_delete);
|
2019-10-22 20:55:04 +02:00
|
|
|
|
|
|
|
occupancy++;
|
2022-06-02 18:13:55 +02:00
|
|
|
if (!is_delete)
|
2019-10-22 20:55:04 +02:00
|
|
|
population++;
|
2021-03-30 02:12:05 +02:00
|
|
|
|
|
|
|
return true;
|
2019-10-22 20:55:04 +02:00
|
|
|
}
|
|
|
|
|
2022-06-03 02:04:12 +02:00
|
|
|
unsigned int bucket_for (const K &key) const
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2019-10-22 20:55:04 +02:00
|
|
|
return bucket_for_hash (key, hb_hash (key));
|
|
|
|
}
|
|
|
|
|
2022-06-03 02:04:12 +02:00
|
|
|
unsigned int bucket_for_hash (const K &key, uint32_t hash) const
|
2019-10-22 20:55:04 +02:00
|
|
|
{
|
2022-06-02 18:32:56 +02:00
|
|
|
hash &= 0x3FFFFFFF; // We only store lower 30bit of hash
|
2019-10-22 20:55:04 +02:00
|
|
|
unsigned int i = hash % prime;
|
2018-05-30 01:28:48 +02:00
|
|
|
unsigned int step = 0;
|
2019-03-30 22:30:22 +01:00
|
|
|
unsigned int tombstone = (unsigned) -1;
|
2022-06-02 18:13:55 +02:00
|
|
|
while (items[i].is_used ())
|
2018-05-30 01:28:48 +02:00
|
|
|
{
|
2019-10-22 20:55:04 +02:00
|
|
|
if (items[i].hash == hash && items[i] == key)
|
2019-05-08 23:46:55 +02:00
|
|
|
return i;
|
2019-03-30 22:30:22 +01:00
|
|
|
if (tombstone == (unsigned) -1 && items[i].is_tombstone ())
|
2019-05-08 23:46:55 +02:00
|
|
|
tombstone = i;
|
2018-05-30 01:28:48 +02:00
|
|
|
i = (i + ++step) & mask;
|
|
|
|
}
|
2019-03-30 22:30:22 +01:00
|
|
|
return tombstone == (unsigned) -1 ? i : tombstone;
|
2018-05-30 01:28:48 +02:00
|
|
|
}
|
2018-06-06 23:55:30 +02:00
|
|
|
|
2018-12-16 20:08:10 +01:00
|
|
|
static unsigned int prime_for (unsigned int shift)
|
2018-06-06 23:55:30 +02:00
|
|
|
{
|
|
|
|
/* Following comment and table copied from glib. */
|
|
|
|
/* Each table size has an associated prime modulo (the first prime
|
|
|
|
* lower than the table size) used to find the initial bucket. Probing
|
|
|
|
* then works modulo 2^n. The prime modulo is necessary to get a
|
|
|
|
* good distribution with poor hash functions.
|
|
|
|
*/
|
|
|
|
/* Not declaring static to make all kinds of compilers happy... */
|
|
|
|
/*static*/ const unsigned int prime_mod [32] =
|
|
|
|
{
|
|
|
|
1, /* For 1 << 0 */
|
|
|
|
2,
|
|
|
|
3,
|
|
|
|
7,
|
|
|
|
13,
|
|
|
|
31,
|
|
|
|
61,
|
|
|
|
127,
|
|
|
|
251,
|
|
|
|
509,
|
|
|
|
1021,
|
|
|
|
2039,
|
|
|
|
4093,
|
|
|
|
8191,
|
|
|
|
16381,
|
|
|
|
32749,
|
|
|
|
65521, /* For 1 << 16 */
|
|
|
|
131071,
|
|
|
|
262139,
|
|
|
|
524287,
|
|
|
|
1048573,
|
|
|
|
2097143,
|
|
|
|
4194301,
|
|
|
|
8388593,
|
|
|
|
16777213,
|
|
|
|
33554393,
|
|
|
|
67108859,
|
|
|
|
134217689,
|
|
|
|
268435399,
|
|
|
|
536870909,
|
|
|
|
1073741789,
|
|
|
|
2147483647 /* For 1 << 31 */
|
|
|
|
};
|
|
|
|
|
|
|
|
if (unlikely (shift >= ARRAY_LENGTH (prime_mod)))
|
|
|
|
return prime_mod[ARRAY_LENGTH (prime_mod) - 1];
|
|
|
|
|
|
|
|
return prime_mod[shift];
|
|
|
|
}
|
2018-05-30 01:28:48 +02:00
|
|
|
};
|
|
|
|
|
2019-03-31 00:29:19 +01:00
|
|
|
/*
|
|
|
|
* hb_map_t
|
|
|
|
*/
|
|
|
|
|
2019-03-30 22:30:22 +01:00
|
|
|
struct hb_map_t : hb_hashmap_t<hb_codepoint_t,
|
2021-11-19 19:49:23 +01:00
|
|
|
hb_codepoint_t,
|
2022-06-02 19:11:35 +02:00
|
|
|
true>
|
2021-11-02 05:45:11 +01:00
|
|
|
{
|
|
|
|
using hashmap = hb_hashmap_t<hb_codepoint_t,
|
2021-11-19 19:49:23 +01:00
|
|
|
hb_codepoint_t,
|
2022-06-02 19:11:35 +02:00
|
|
|
true>;
|
2021-11-02 05:45:11 +01:00
|
|
|
|
|
|
|
~hb_map_t () = default;
|
2022-05-12 21:05:32 +02:00
|
|
|
hb_map_t () : hashmap () {}
|
|
|
|
hb_map_t (const hb_map_t &o) : hashmap ((hashmap &) o) {}
|
|
|
|
hb_map_t (hb_map_t &&o) : hashmap (std::move ((hashmap &) o)) {}
|
2021-11-19 19:49:23 +01:00
|
|
|
hb_map_t& operator= (const hb_map_t&) = default;
|
|
|
|
hb_map_t& operator= (hb_map_t&&) = default;
|
2021-11-02 05:45:11 +01:00
|
|
|
hb_map_t (std::initializer_list<hb_pair_t<hb_codepoint_t, hb_codepoint_t>> lst) : hashmap (lst) {}
|
|
|
|
template <typename Iterable,
|
|
|
|
hb_requires (hb_is_iterable (Iterable))>
|
|
|
|
hb_map_t (const Iterable &o) : hashmap (o) {}
|
|
|
|
};
|
2018-05-30 01:28:48 +02:00
|
|
|
|
2022-06-22 04:29:52 +02:00
|
|
|
template <typename K, typename V>
|
|
|
|
static inline
|
|
|
|
hb_hashmap_t<K, V>* hb_hashmap_create ()
|
|
|
|
{
|
|
|
|
using hashmap = hb_hashmap_t<K, V>;
|
|
|
|
hashmap* map;
|
|
|
|
if (!(map = hb_object_create<hashmap> ()))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename K, typename V>
|
|
|
|
static inline
|
|
|
|
void hb_hashmap_destroy (hb_hashmap_t<K, V>* map)
|
|
|
|
{
|
|
|
|
if (!hb_object_destroy (map))
|
|
|
|
return;
|
2022-07-20 23:03:20 +02:00
|
|
|
|
2022-06-22 04:29:52 +02:00
|
|
|
hb_free (map);
|
|
|
|
}
|
|
|
|
|
2022-07-20 22:34:55 +02:00
|
|
|
namespace hb {
|
|
|
|
|
|
|
|
template <typename K, typename V>
|
|
|
|
struct vtable<hb_hashmap_t<K, V>>
|
|
|
|
{
|
|
|
|
static constexpr auto destroy = hb_hashmap_destroy<K,V>;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-08-26 07:36:36 +02:00
|
|
|
#endif /* HB_MAP_HH */
|