/src/harfbuzz/src/hb-set.hh
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright © 2012,2017 Google, Inc. |
3 | | * Copyright © 2021 Behdad Esfahbod |
4 | | * |
5 | | * This is part of HarfBuzz, a text shaping library. |
6 | | * |
7 | | * Permission is hereby granted, without written agreement and without |
8 | | * license or royalty fees, to use, copy, modify, and distribute this |
9 | | * software and its documentation for any purpose, provided that the |
10 | | * above copyright notice and the following two paragraphs appear in |
11 | | * all copies of this software. |
12 | | * |
13 | | * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
14 | | * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
15 | | * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
16 | | * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
17 | | * DAMAGE. |
18 | | * |
19 | | * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
20 | | * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
21 | | * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
22 | | * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
23 | | * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
24 | | * |
25 | | * Google Author(s): Behdad Esfahbod |
26 | | */ |
27 | | |
28 | | #ifndef HB_SET_HH |
29 | | #define HB_SET_HH |
30 | | |
31 | | #include "hb.hh" |
32 | | #include "hb-bit-set-invertible.hh" |
33 | | |
34 | | |
35 | | template <typename impl_t> |
36 | | struct hb_sparseset_t |
37 | | { |
38 | | static constexpr bool realloc_move = true; |
39 | | |
40 | | hb_object_header_t header; |
41 | | impl_t s; |
42 | | |
43 | 0 | hb_sparseset_t () { init (); } |
44 | 0 | ~hb_sparseset_t () { fini (); } |
45 | | |
46 | 0 | hb_sparseset_t (const hb_sparseset_t& other) : hb_sparseset_t () { set (other); } |
47 | 0 | hb_sparseset_t (hb_sparseset_t&& other) : hb_sparseset_t () { s = std::move (other.s); } |
48 | 0 | hb_sparseset_t& operator = (const hb_sparseset_t& other) { set (other); return *this; } |
49 | 0 | hb_sparseset_t& operator = (hb_sparseset_t&& other) { s = std::move (other.s); return *this; } |
50 | | friend void swap (hb_sparseset_t& a, hb_sparseset_t& b) { hb_swap (a.s, b.s); } |
51 | | |
52 | | hb_sparseset_t (std::initializer_list<hb_codepoint_t> lst) : hb_sparseset_t () |
53 | | { |
54 | | for (auto&& item : lst) |
55 | | add (item); |
56 | | } |
57 | | template <typename Iterable, |
58 | | hb_requires (hb_is_iterable (Iterable))> |
59 | | hb_sparseset_t (const Iterable &o) : hb_sparseset_t () |
60 | | { |
61 | | hb_copy (o, *this); |
62 | | } |
63 | | |
64 | | void init () |
65 | 0 | { |
66 | 0 | hb_object_init (this); |
67 | 0 | s.init (); |
68 | 0 | } |
69 | | void fini () |
70 | 0 | { |
71 | 0 | hb_object_fini (this); |
72 | 0 | s.fini (); |
73 | 0 | } |
74 | | |
75 | 0 | explicit operator bool () const { return !is_empty (); } |
76 | | |
77 | 0 | void err () { s.err (); } |
78 | 0 | bool in_error () const { return s.in_error (); } |
79 | | |
80 | | void alloc (unsigned sz) { s.alloc (sz); } |
81 | 0 | void reset () { s.reset (); } |
82 | 0 | void clear () { s.clear (); } |
83 | 0 | void invert () { s.invert (); } |
84 | 0 | bool is_inverted () const { return s.is_inverted (); } |
85 | 0 | bool is_empty () const { return s.is_empty (); } |
86 | 0 | uint32_t hash () const { return s.hash (); } |
87 | | |
88 | 0 | void add (hb_codepoint_t g) { s.add (g); } |
89 | 0 | bool add_range (hb_codepoint_t a, hb_codepoint_t b) { return s.add_range (a, b); } |
90 | | |
91 | | template <typename T> |
92 | | void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) |
93 | 0 | { s.add_array (array, count, stride); } Unexecuted instantiation: void hb_sparseset_t<hb_bit_set_invertible_t>::add_array<OT::Index>(OT::Index const*, unsigned int, unsigned int) Unexecuted instantiation: void hb_sparseset_t<hb_bit_set_invertible_t>::add_array<OT::HBGlyphID16>(OT::HBGlyphID16 const*, unsigned int, unsigned int) |
94 | | template <typename T> |
95 | 0 | void add_array (const hb_array_t<const T>& arr) { add_array (&arr, arr.len ()); } |
96 | | |
97 | | /* Might return false if array looks unsorted. |
98 | | * Used for faster rejection of corrupt data. */ |
99 | | template <typename T> |
100 | | bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) |
101 | 0 | { return s.add_sorted_array (array, count, stride); } Unexecuted instantiation: bool hb_sparseset_t<hb_bit_set_invertible_t>::add_sorted_array<OT::HBGlyphID16>(OT::HBGlyphID16 const*, unsigned int, unsigned int) Unexecuted instantiation: bool hb_sparseset_t<hb_bit_set_invertible_t>::add_sorted_array<unsigned int>(unsigned int const*, unsigned int, unsigned int) |
102 | | template <typename T> |
103 | 0 | bool add_sorted_array (const hb_sorted_array_t<const T>& arr) { return add_sorted_array (&arr, arr.len ()); } |
104 | | |
105 | 0 | void del (hb_codepoint_t g) { s.del (g); } |
106 | 0 | void del_range (hb_codepoint_t a, hb_codepoint_t b) { s.del_range (a, b); } |
107 | | |
108 | 0 | bool get (hb_codepoint_t g) const { return s.get (g); } |
109 | | |
110 | | /* Has interface. */ |
111 | 0 | bool operator [] (hb_codepoint_t k) const { return get (k); } |
112 | 0 | bool has (hb_codepoint_t k) const { return (*this)[k]; } |
113 | | |
114 | | /* Predicate. */ |
115 | | bool operator () (hb_codepoint_t k) const { return has (k); } |
116 | | |
117 | | /* Sink interface. */ |
118 | | hb_sparseset_t& operator << (hb_codepoint_t v) |
119 | 0 | { add (v); return *this; } |
120 | | hb_sparseset_t& operator << (const hb_codepoint_pair_t& range) |
121 | 0 | { add_range (range.first, range.second); return *this; } |
122 | | |
123 | | bool intersects (hb_codepoint_t first, hb_codepoint_t last) const |
124 | 0 | { return s.intersects (first, last); } |
125 | | |
126 | 0 | void set (const hb_sparseset_t &other) { s.set (other.s); } |
127 | | |
128 | 0 | bool is_equal (const hb_sparseset_t &other) const { return s.is_equal (other.s); } |
129 | | bool operator == (const hb_set_t &other) const { return is_equal (other); } |
130 | | bool operator != (const hb_set_t &other) const { return !is_equal (other); } |
131 | | |
132 | 0 | bool is_subset (const hb_sparseset_t &larger_set) const { return s.is_subset (larger_set.s); } |
133 | | |
134 | 0 | void union_ (const hb_sparseset_t &other) { s.union_ (other.s); } |
135 | 0 | void intersect (const hb_sparseset_t &other) { s.intersect (other.s); } |
136 | 0 | void subtract (const hb_sparseset_t &other) { s.subtract (other.s); } |
137 | 0 | void symmetric_difference (const hb_sparseset_t &other) { s.symmetric_difference (other.s); } |
138 | | |
139 | 0 | bool next (hb_codepoint_t *codepoint) const { return s.next (codepoint); } |
140 | 0 | bool previous (hb_codepoint_t *codepoint) const { return s.previous (codepoint); } |
141 | | bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const |
142 | 0 | { return s.next_range (first, last); } |
143 | | bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const |
144 | 0 | { return s.previous_range (first, last); } |
145 | | unsigned int next_many (hb_codepoint_t codepoint, hb_codepoint_t *out, unsigned int size) const |
146 | 0 | { return s.next_many (codepoint, out, size); } |
147 | | |
148 | 0 | unsigned int get_population () const { return s.get_population (); } |
149 | 0 | hb_codepoint_t get_min () const { return s.get_min (); } |
150 | 0 | hb_codepoint_t get_max () const { return s.get_max (); } |
151 | | |
152 | | static constexpr hb_codepoint_t INVALID = impl_t::INVALID; |
153 | | |
154 | | /* |
155 | | * Iterator implementation. |
156 | | */ |
157 | | using iter_t = typename impl_t::iter_t; |
158 | 0 | iter_t iter () const { return iter_t (this->s); } |
159 | | operator iter_t () const { return iter (); } |
160 | | }; |
161 | | |
162 | | struct hb_set_t : hb_sparseset_t<hb_bit_set_invertible_t> |
163 | | { |
164 | | using sparseset = hb_sparseset_t<hb_bit_set_invertible_t>; |
165 | | |
166 | | ~hb_set_t () = default; |
167 | 0 | hb_set_t () : sparseset () {}; |
168 | 0 | hb_set_t (const hb_set_t &o) : sparseset ((sparseset &) o) {}; |
169 | 0 | hb_set_t (hb_set_t&& o) : sparseset (std::move ((sparseset &) o)) {} |
170 | 0 | hb_set_t& operator = (const hb_set_t&) = default; |
171 | 0 | hb_set_t& operator = (hb_set_t&&) = default; |
172 | 0 | hb_set_t (std::initializer_list<hb_codepoint_t> lst) : sparseset (lst) {} |
173 | | template <typename Iterable, |
174 | | hb_requires (hb_is_iterable (Iterable))> |
175 | | hb_set_t (const Iterable &o) : sparseset (o) {} |
176 | | |
177 | | hb_set_t& operator << (hb_codepoint_t v) |
178 | 0 | { sparseset::operator<< (v); return *this; } |
179 | | hb_set_t& operator << (const hb_codepoint_pair_t& range) |
180 | 0 | { sparseset::operator<< (range); return *this; } |
181 | | }; |
182 | | |
183 | | static_assert (hb_set_t::INVALID == HB_SET_VALUE_INVALID, ""); |
184 | | |
185 | | |
186 | | #endif /* HB_SET_HH */ |