w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

hb-object.hh
Go to the documentation of this file.
1 /*
2  * Copyright © 2007 Chris Wilson
3  * Copyright © 2009,2010 Red Hat, Inc.
4  * Copyright © 2011,2012 Google, Inc.
5  *
6  * This is part of HarfBuzz, a text shaping library.
7  *
8  * Permission is hereby granted, without written agreement and without
9  * license or royalty fees, to use, copy, modify, and distribute this
10  * software and its documentation for any purpose, provided that the
11  * above copyright notice and the following two paragraphs appear in
12  * all copies of this software.
13  *
14  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
15  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
17  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
18  * DAMAGE.
19  *
20  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
21  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
22  * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
23  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
24  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
25  *
26  * Contributor(s):
27  * Chris Wilson <chris@chris-wilson.co.uk>
28  * Red Hat Author(s): Behdad Esfahbod
29  * Google Author(s): Behdad Esfahbod
30  */
31 
32 #ifndef HB_OBJECT_HH
33 #define HB_OBJECT_HH
34 
35 #include "hb.hh"
36 #include "hb-atomic.hh"
37 #include "hb-mutex.hh"
38 #include "hb-vector.hh"
39 
40 
41 /*
42  * Lockable set
43  */
44 
45 template <typename item_t, typename lock_t>
47 {
49 
50  void init () { items.init (); }
51 
52  template <typename T>
53  item_t *replace_or_insert (T v, lock_t &l, bool replace)
54  {
55  l.lock ();
56  item_t *item = items.find (v);
57  if (item) {
58  if (replace) {
59  item_t old = *item;
60  *item = v;
61  l.unlock ();
62  old.fini ();
63  }
64  else {
65  item = nullptr;
66  l.unlock ();
67  }
68  } else {
69  item = items.push (v);
70  l.unlock ();
71  }
72  return item;
73  }
74 
75  template <typename T>
76  void remove (T v, lock_t &l)
77  {
78  l.lock ();
79  item_t *item = items.find (v);
80  if (item)
81  {
82  item_t old = *item;
83  *item = items[items.length - 1];
84  items.pop ();
85  l.unlock ();
86  old.fini ();
87  } else {
88  l.unlock ();
89  }
90  }
91 
92  template <typename T>
93  bool find (T v, item_t *i, lock_t &l)
94  {
95  l.lock ();
96  item_t *item = items.find (v);
97  if (item)
98  *i = *item;
99  l.unlock ();
100  return !!item;
101  }
102 
103  template <typename T>
104  item_t *find_or_insert (T v, lock_t &l)
105  {
106  l.lock ();
107  item_t *item = items.find (v);
108  if (!item) {
109  item = items.push (v);
110  }
111  l.unlock ();
112  return item;
113  }
114 
115  void fini (lock_t &l)
116  {
117  if (!items.length)
118  {
119  /* No need to lock. */
120  items.fini ();
121  return;
122  }
123  l.lock ();
124  while (items.length)
125  {
126  item_t old = items[items.length - 1];
127  items.pop ();
128  l.unlock ();
129  old.fini ();
130  l.lock ();
131  }
132  items.fini ();
133  l.unlock ();
134  }
135 
136 };
137 
138 
139 /*
140  * Reference-count.
141  */
142 
143 #define HB_REFERENCE_COUNT_INERT_VALUE 0
144 #define HB_REFERENCE_COUNT_POISON_VALUE -0x0000DEAD
145 #define HB_REFERENCE_COUNT_INIT {HB_ATOMIC_INT_INIT (HB_REFERENCE_COUNT_INERT_VALUE)}
146 
148 {
150 
151  void init (int v = 1) { ref_count.set_relaxed (v); }
152  int get_relaxed () const { return ref_count.get_relaxed (); }
153  int inc () const { return ref_count.inc (); }
154  int dec () const { return ref_count.dec (); }
156 
158  bool is_valid () const { return ref_count.get_relaxed () > 0; }
159 };
160 
161 
162 /* user_data */
163 
165 {
168  void *data;
170 
171  bool operator == (const hb_user_data_key_t *other_key) const { return key == other_key; }
172  bool operator == (const hb_user_data_item_t &other) const { return key == other.key; }
173 
174  void fini () { if (destroy) destroy (data); }
175  };
176 
179 
180  void init () { lock.init (); items.init (); }
181 
183  void * data,
184  hb_destroy_func_t destroy,
186 
188 
189  void fini () { items.fini (lock); lock.fini (); }
190 };
191 
192 
193 /*
194  * Object header
195  */
196 
198 {
202 };
203 #define HB_OBJECT_HEADER_STATIC \
204  { \
205  HB_REFERENCE_COUNT_INIT, \
206  HB_ATOMIC_INT_INIT (false), \
207  HB_ATOMIC_PTR_INIT (nullptr) \
208  }
209 
210 
211 /*
212  * Object
213  */
214 
215 template <typename Type>
216 static inline void hb_object_trace (const Type *obj, const char *function)
217 {
218  DEBUG_MSG (OBJECT, (void *) obj,
219  "%s refcount=%d",
220  function,
221  obj ? obj->header.ref_count.get_relaxed () : 0);
222 }
223 
224 template <typename Type>
225 static inline Type *hb_object_create ()
226 {
227  Type *obj = (Type *) calloc (1, sizeof (Type));
228 
229  if (unlikely (!obj))
230  return obj;
231 
232  hb_object_init (obj);
233  hb_object_trace (obj, HB_FUNC);
234  return obj;
235 }
236 template <typename Type>
237 static inline void hb_object_init (Type *obj)
238 {
239  obj->header.ref_count.init ();
240  obj->header.writable.set_relaxed (true);
241  obj->header.user_data.init ();
242 }
243 template <typename Type>
244 static inline bool hb_object_is_inert (const Type *obj)
245 {
246  return unlikely (obj->header.ref_count.is_inert ());
247 }
248 template <typename Type>
249 static inline bool hb_object_is_valid (const Type *obj)
250 {
251  return likely (obj->header.ref_count.is_valid ());
252 }
253 template <typename Type>
254 static inline bool hb_object_is_immutable (const Type *obj)
255 {
256  return !obj->header.writable.get_relaxed ();
257 }
258 template <typename Type>
259 static inline void hb_object_make_immutable (const Type *obj)
260 {
261  obj->header.writable.set_relaxed (false);
262 }
263 template <typename Type>
264 static inline Type *hb_object_reference (Type *obj)
265 {
266  hb_object_trace (obj, HB_FUNC);
267  if (unlikely (!obj || hb_object_is_inert (obj)))
268  return obj;
269  assert (hb_object_is_valid (obj));
270  obj->header.ref_count.inc ();
271  return obj;
272 }
273 template <typename Type>
274 static inline bool hb_object_destroy (Type *obj)
275 {
276  hb_object_trace (obj, HB_FUNC);
277  if (unlikely (!obj || hb_object_is_inert (obj)))
278  return false;
279  assert (hb_object_is_valid (obj));
280  if (obj->header.ref_count.dec () != 1)
281  return false;
282 
283  hb_object_fini (obj);
284  return true;
285 }
286 template <typename Type>
287 static inline void hb_object_fini (Type *obj)
288 {
289  obj->header.ref_count.fini (); /* Do this before user_data */
290  hb_user_data_array_t *user_data = obj->header.user_data.get ();
291  if (user_data)
292  {
293  user_data->fini ();
294  free (user_data);
295  user_data = nullptr;
296  }
297 }
298 template <typename Type>
299 static inline bool hb_object_set_user_data (Type *obj,
301  void * data,
302  hb_destroy_func_t destroy,
304 {
305  if (unlikely (!obj || hb_object_is_inert (obj)))
306  return false;
307  assert (hb_object_is_valid (obj));
308 
309 retry:
310  hb_user_data_array_t *user_data = obj->header.user_data.get ();
311  if (unlikely (!user_data))
312  {
313  user_data = (hb_user_data_array_t *) calloc (sizeof (hb_user_data_array_t), 1);
314  if (unlikely (!user_data))
315  return false;
316  user_data->init ();
317  if (unlikely (!obj->header.user_data.cmpexch (nullptr, user_data)))
318  {
319  user_data->fini ();
320  free (user_data);
321  goto retry;
322  }
323  }
324 
325  return user_data->set (key, data, destroy, replace);
326 }
327 
328 template <typename Type>
329 static inline void *hb_object_get_user_data (Type *obj,
331 {
332  if (unlikely (!obj || hb_object_is_inert (obj)))
333  return nullptr;
334  assert (hb_object_is_valid (obj));
335  hb_user_data_array_t *user_data = obj->header.user_data.get ();
336  if (!user_data)
337  return nullptr;
338  return user_data->get (key);
339 }
340 
341 
342 #endif /* HB_OBJECT_HH */
static int item
Definition: brushtopbm.c:66
#define free(a)
Definition: decNumber.cpp:310
int v
Definition: dviconv.c:10
struct rect data
Definition: dvipdfm.c:64
void replace(char *, char *)
Definition: dvispc.c:2100
#define T
Definition: fmt.h:20
assert(pcxLoadImage24((char *)((void *) 0), fp, pinfo, hdr))
#define likely(x)
Definition: jbig2arith.cc:115
#define unlikely(x)
Definition: jbig2arith.cc:116
small capitals from c petite p scientific i
Definition: afcover.h:80
voidp calloc()
@ other
Definition: mtxline.h:22
void(* hb_destroy_func_t)(void *user_data)
Definition: hb-common.h:690
int hb_bool_t
Definition: hb-common.h:97
#define DEBUG_MSG(WHAT, OBJ,...)
Definition: hb-debug.hh:232
static bool hb_object_is_inert(const Type *obj)
Definition: hb-object.hh:244
#define HB_REFERENCE_COUNT_INERT_VALUE
Definition: hb-object.hh:143
static void hb_object_fini(Type *obj)
Definition: hb-object.hh:287
static void * hb_object_get_user_data(Type *obj, hb_user_data_key_t *key)
Definition: hb-object.hh:329
#define HB_REFERENCE_COUNT_POISON_VALUE
Definition: hb-object.hh:144
static bool hb_object_is_valid(const Type *obj)
Definition: hb-object.hh:249
static void hb_object_trace(const Type *obj, const char *function)
Definition: hb-object.hh:216
static bool hb_object_destroy(Type *obj)
Definition: hb-object.hh:274
static bool hb_object_is_immutable(const Type *obj)
Definition: hb-object.hh:254
static void hb_object_make_immutable(const Type *obj)
Definition: hb-object.hh:259
static void hb_object_init(Type *obj)
Definition: hb-object.hh:237
static Type * hb_object_create()
Definition: hb-object.hh:225
static Type * hb_object_reference(Type *obj)
Definition: hb-object.hh:264
static bool hb_object_set_user_data(Type *obj, hb_user_data_key_t *key, void *data, hb_destroy_func_t destroy, hb_bool_t replace)
Definition: hb-object.hh:299
#define HB_FUNC
Definition: hb.hh:290
#define HB_INTERNAL
Definition: hb.hh:265
int get_relaxed() const
Definition: hb-atomic.hh:267
void set_relaxed(int v_)
Definition: hb-atomic.hh:265
bool find(T v, item_t *i, lock_t &l)
Definition: hb-object.hh:93
void remove(T v, lock_t &l)
Definition: hb-object.hh:76
void fini(lock_t &l)
Definition: hb-object.hh:115
item_t * find_or_insert(T v, lock_t &l)
Definition: hb-object.hh:104
item_t * replace_or_insert(T v, lock_t &l, bool replace)
Definition: hb-object.hh:53
hb_vector_t< item_t > items
Definition: hb-object.hh:48
void fini()
Definition: hb-mutex.hh:121
void init()
Definition: hb-mutex.hh:118
hb_atomic_ptr_t< hb_user_data_array_t > user_data
Definition: hb-object.hh:201
hb_atomic_int_t writable
Definition: hb-object.hh:200
hb_reference_count_t ref_count
Definition: hb-object.hh:199
void init(int v=1)
Definition: hb-object.hh:151
bool is_inert() const
Definition: hb-object.hh:157
int get_relaxed() const
Definition: hb-object.hh:152
hb_atomic_int_t ref_count
Definition: hb-object.hh:149
bool is_valid() const
Definition: hb-object.hh:158
bool operator==(const hb_user_data_key_t *other_key) const
Definition: hb-object.hh:171
void * get(hb_user_data_key_t *key)
Definition: hb-static.cc:104
hb_lockable_set_t< hb_user_data_item_t, hb_mutex_t > items
Definition: hb-object.hh:178
bool set(hb_user_data_key_t *key, void *data, hb_destroy_func_t destroy, hb_bool_t replace)
Definition: hb-static.cc:83
#define key
Definition: tex2xindy.c:753