harfbuzz/src/hb-map.hh

435 lines
11 KiB
C++
Raw Normal View History

/*
2018-05-30 02:58:46 +02:00
* Copyright © 2018 Google, Inc.
*
* 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
*/
#ifndef HB_MAP_HH
#define HB_MAP_HH
#include "hb.hh"
/*
* hb_hashmap_t
*/
template <typename K, typename V,
typename k_invalid_t = K,
typename v_invalid_t = V,
k_invalid_t kINVALID = std::is_pointer<K>::value ? 0 : std::is_signed<K>::value ? hb_int_min (K) : (K) -1,
v_invalid_t vINVALID = std::is_pointer<V>::value ? 0 : std::is_signed<V>::value ? hb_int_min (V) : (V) -1>
struct hb_hashmap_t
{
hb_hashmap_t () { init (); }
hb_hashmap_t (std::nullptr_t) : hb_hashmap_t () {}
~hb_hashmap_t () { fini (); }
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); }
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 ()
{
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
struct item_t
{
K key;
uint32_t hash;
V value;
2022-01-13 20:38:26 +01:00
void clear ()
{
new (std::addressof (key)) K ();
key = hb_coerce<K> (kINVALID);
new (std::addressof (value)) V ();
value = hb_coerce<V> (vINVALID);
2022-01-13 20:38:26 +01:00
hash = 0;
}
bool operator == (const K &o) { return hb_deref (key) == hb_deref (o); }
bool operator == (const item_t &o) { return *this == o.key; }
2022-01-10 22:57:38 +01:00
bool is_unused () const
{
const K inv = hb_coerce<K> (kINVALID);
2022-01-10 22:57:38 +01:00
return key == inv;
}
bool is_tombstone () const
{
const K kinv = hb_coerce<K> (kINVALID);
const V vinv = hb_coerce<V> (vINVALID);
2022-01-10 22:57:38 +01:00
return key != kinv && value == vinv;
}
bool is_real () const
{
const K kinv = hb_coerce<K> (kINVALID);
const V vinv = hb_coerce<V> (vINVALID);
2022-01-10 22:57:38 +01:00
return key != kinv && value != vinv;
}
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-05-26 19:20:27 +02:00
uint32_t total_hash () const
{ return (hash * 31) + hb_hash (value); }
};
hb_object_header_t header;
bool successful; /* Allocations successful */
unsigned int population; /* Not including tombstones. */
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);
}
void init_shallow ()
{
successful = true;
population = occupancy = 0;
mask = 0;
prime = 0;
items = nullptr;
}
void init ()
{
hb_object_init (this);
init_shallow ();
}
void fini_shallow ()
{
if (likely (items)) {
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;
}
void fini ()
{
hb_object_fini (this);
fini_shallow ();
}
2019-03-31 01:51:26 +01:00
void reset ()
{
2019-04-03 05:13:16 +02:00
successful = true;
clear ();
2019-03-31 01:51:26 +01:00
}
bool in_error () const { return !successful; }
bool resize (unsigned new_population = 0)
{
if (unlikely (!successful)) return false;
unsigned int power = hb_bit_storage (hb_max (population, new_population) * 2 + 8);
unsigned int new_size = 1u << power;
item_t *new_items = (item_t *) hb_malloc ((size_t) new_size * sizeof (item_t));
if (unlikely (!new_items))
{
successful = false;
return false;
}
for (auto &_ : hb_iter (new_items, new_size))
_.clear ();
unsigned int old_size = mask + 1;
item_t *old_items = items;
/* Switch to new, empty, array. */
population = occupancy = 0;
mask = new_size - 1;
prime = prime_for (power);
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
{
if (old_items[i].is_real ())
2022-01-13 23:06:58 +01:00
{
set_with_hash (old_items[i].key,
old_items[i].hash,
std::move (old_items[i].value));
2022-01-13 23:06:58 +01:00
}
old_items[i].~item_t ();
}
hb_free (old_items);
return true;
}
2021-11-02 06:13:34 +01:00
bool set (K key, const V& value) { return set_with_hash (key, hb_hash (key), value); }
bool set (K key, V&& value) { return set_with_hash (key, hb_hash (key), std::move (value)); }
V get (K key) const
{
if (unlikely (!items)) return hb_coerce<V> (vINVALID);
unsigned int i = bucket_for (key);
return items[i].is_real () && items[i] == key ? items[i].value : hb_coerce<V> (vINVALID);
}
void del (K key) { set (key, hb_coerce<V> (vINVALID)); }
2019-01-28 22:34:04 +01:00
/* Has interface. */
typedef V value_t;
value_t operator [] (K k) const { return get (k); }
bool has (K k, V *vp = nullptr) const
{
const V &v = (*this)[k];
if (vp) *vp = v;
const V vinv = hb_coerce<V> (vINVALID);
return v != vinv;
}
2019-01-28 22:34:04 +01:00
/* Projection. */
V operator () (K k) const { return get (k); }
void clear ()
{
if (unlikely (!successful)) return;
if (items)
for (auto &_ : hb_iter (items, mask + 1))
_.clear ();
population = occupancy = 0;
}
bool is_empty () const { return population == 0; }
explicit operator bool () const { return !is_empty (); }
uint32_t hash () const
2022-05-19 21:38:52 +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;
}
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); }
unsigned int get_population () const { return population; }
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)
)
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)
| hb_map (hb_ridentity)
2019-05-08 21:47:18 +02:00
)
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)
| hb_map (hb_ridentity)
2019-05-09 00:08:10 +02:00
)
2019-05-08 21:47:18 +02:00
/* Sink interface. */
2020-04-23 19:50:02 +02:00
hb_hashmap_t& operator << (const hb_pair_t<K, V>& v)
{ set (v.first, v.second); return *this; }
protected:
2021-11-02 06:13:34 +01:00
template <typename VV>
bool set_with_hash (K key, uint32_t hash, VV&& value)
{
2021-03-30 02:12:05 +02:00
if (unlikely (!successful)) return false;
const K kinv = hb_coerce<K> (kINVALID);
2022-01-10 22:57:38 +01:00
if (unlikely (key == kinv)) return true;
2021-03-30 02:12:05 +02:00
if (unlikely ((occupancy + occupancy / 2) >= mask && !resize ())) return false;
unsigned int i = bucket_for_hash (key, hash);
const V vinv = hb_coerce<V> (vINVALID);
2022-01-10 22:57:38 +01:00
if (value == vinv && items[i].key != key)
2021-03-30 02:12:05 +02:00
return true; /* Trying to delete non-existent key. */
if (!items[i].is_unused ())
{
occupancy--;
if (!items[i].is_tombstone ())
population--;
}
items[i].key = key;
items[i].value = value;
items[i].hash = hash;
occupancy++;
if (!items[i].is_tombstone ())
population++;
2021-03-30 02:12:05 +02:00
return true;
}
unsigned int bucket_for (K key) const
{
return bucket_for_hash (key, hb_hash (key));
}
unsigned int bucket_for_hash (K key, uint32_t hash) const
{
unsigned int i = hash % prime;
unsigned int step = 0;
unsigned int tombstone = (unsigned) -1;
while (!items[i].is_unused ())
{
if (items[i].hash == hash && items[i] == key)
2019-05-08 23:46:55 +02:00
return i;
if (tombstone == (unsigned) -1 && items[i].is_tombstone ())
2019-05-08 23:46:55 +02:00
tombstone = i;
i = (i + ++step) & mask;
}
return tombstone == (unsigned) -1 ? i : tombstone;
}
static unsigned int prime_for (unsigned int shift)
{
/* 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];
}
};
2019-03-31 00:29:19 +01:00
/*
* hb_map_t
*/
struct hb_map_t : hb_hashmap_t<hb_codepoint_t,
hb_codepoint_t,
hb_codepoint_t,
hb_codepoint_t,
HB_MAP_VALUE_INVALID,
2021-11-02 05:45:11 +01:00
HB_MAP_VALUE_INVALID>
{
using hashmap = hb_hashmap_t<hb_codepoint_t,
hb_codepoint_t,
hb_codepoint_t,
2021-11-02 05:45:11 +01:00
hb_codepoint_t,
HB_MAP_VALUE_INVALID,
HB_MAP_VALUE_INVALID>;
~hb_map_t () = default;
hb_map_t () : hashmap () {}
hb_map_t (std::nullptr_t) : hb_map_t () {}
hb_map_t (const hb_map_t &o) : hashmap ((hashmap &) o) {}
hb_map_t (hb_map_t &&o) : hashmap (std::move ((hashmap &) o)) {}
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) {}
};
#endif /* HB_MAP_HH */