/* reference_count */
-#define HB_REFERENCE_COUNT_INVALID_VALUE ((hb_atomic_int_t) -1)
-#define HB_REFERENCE_COUNT_INVALID {HB_REFERENCE_COUNT_INVALID_VALUE}
+#define HB_REFERENCE_COUNT_INERT_VALUE -1
+#define HB_REFERENCE_COUNT_POISON_VALUE -0x0000DEAD
+#define HB_REFERENCE_COUNT_INIT {HB_ATOMIC_INT_INIT(HB_REFERENCE_COUNT_INERT_VALUE)}
+
struct hb_reference_count_t
{
hb_atomic_int_t ref_count;
- inline void init (int v) { ref_count = v; }
- inline int inc (void) { return hb_atomic_int_add (const_cast<hb_atomic_int_t &> (ref_count), 1); }
- inline int dec (void) { return hb_atomic_int_add (const_cast<hb_atomic_int_t &> (ref_count), -1); }
- inline void finish (void) { ref_count = HB_REFERENCE_COUNT_INVALID_VALUE; }
-
- inline bool is_invalid (void) const { return ref_count == HB_REFERENCE_COUNT_INVALID_VALUE; }
+ inline void init (int v) { ref_count.set_unsafe (v); }
+ inline int get_unsafe (void) const { return ref_count.get_unsafe (); }
+ inline int inc (void) { return ref_count.inc (); }
+ inline int dec (void) { return ref_count.dec (); }
+ inline void finish (void) { ref_count.set_unsafe (HB_REFERENCE_COUNT_POISON_VALUE); }
+ inline bool is_inert (void) const { return ref_count.get_unsafe () == HB_REFERENCE_COUNT_INERT_VALUE; }
+ inline bool is_valid (void) const { return ref_count.get_unsafe () > 0; }
};
/* user_data */
-#define HB_USER_DATA_ARRAY_INIT {HB_LOCKABLE_SET_INIT}
+#define HB_USER_DATA_ARRAY_INIT {HB_MUTEX_INIT, HB_LOCKABLE_SET_INIT}
struct hb_user_data_array_t
{
- /* TODO Add tracing. */
-
struct hb_user_data_item_t {
hb_user_data_key_t *key;
void *data;
void finish (void) { if (destroy) destroy (data); }
};
+ hb_mutex_t lock;
hb_lockable_set_t<hb_user_data_item_t, hb_mutex_t> items;
- inline void init (void) { items.init (); }
+ inline void init (void) { lock.init (); items.init (); }
HB_INTERNAL bool set (hb_user_data_key_t *key,
void * data,
hb_destroy_func_t destroy,
- hb_bool_t replace,
- hb_mutex_t &lock);
+ hb_bool_t replace);
- HB_INTERNAL void *get (hb_user_data_key_t *key,
- hb_mutex_t &lock);
+ HB_INTERNAL void *get (hb_user_data_key_t *key);
- HB_INTERNAL void finish (hb_mutex_t &lock);
+ inline void finish (void) { items.finish (lock); lock.finish (); }
};
struct hb_object_header_t
{
hb_reference_count_t ref_count;
- hb_mutex_t mutex;
hb_user_data_array_t user_data;
-#define HB_OBJECT_HEADER_STATIC {HB_REFERENCE_COUNT_INVALID, HB_MUTEX_INIT, HB_USER_DATA_ARRAY_INIT}
-
- static inline void *create (unsigned int size) {
- hb_object_header_t *obj = (hb_object_header_t *) calloc (1, size);
-
- if (likely (obj))
- obj->init ();
-
- return obj;
- }
-
- inline void init (void) {
- ref_count.init (1);
- mutex.init ();
- user_data.init ();
- }
-
- inline bool is_inert (void) const {
- return unlikely (ref_count.is_invalid ());
- }
-
- inline void reference (void) {
- if (unlikely (!this || this->is_inert ()))
- return;
- ref_count.inc ();
- }
-
- inline bool destroy (void) {
- if (unlikely (!this || this->is_inert ()))
- return false;
- if (ref_count.dec () != 1)
- return false;
-
- ref_count.finish (); /* Do this before user_data */
- user_data.finish (mutex);
- mutex.finish ();
-
- return true;
- }
-
- inline void lock (void) {
- mutex.lock ();
- }
-
- inline void unlock (void) {
- mutex.unlock ();
- }
-
- inline bool set_user_data (hb_user_data_key_t *key,
- void * data,
- hb_destroy_func_t destroy_func,
- hb_bool_t replace) {
- if (unlikely (!this || this->is_inert ()))
- return false;
-
- return user_data.set (key, data, destroy_func, replace, mutex);
- }
-
- inline void *get_user_data (hb_user_data_key_t *key) {
- if (unlikely (!this || this->is_inert ()))
- return NULL;
-
- return user_data.get (key, mutex);
- }
-
- inline void trace (const char *function) const {
- if (unlikely (!this)) return;
- /* TODO We cannot use DEBUG_MSG_FUNC here since that one currently only
- * prints the class name and throws away the template info. */
- DEBUG_MSG (OBJECT, (void *) this,
- "%s refcount=%d",
- function,
- this ? ref_count.ref_count : 0);
- }
+#define HB_OBJECT_HEADER_STATIC {HB_REFERENCE_COUNT_INIT, HB_USER_DATA_ARRAY_INIT}
private:
ASSERT_POD ();
template <typename Type>
static inline void hb_object_trace (const Type *obj, const char *function)
{
- obj->header.trace (function);
+ DEBUG_MSG (OBJECT, (void *) obj,
+ "%s refcount=%d",
+ function,
+ obj ? obj->header.ref_count.get_unsafe () : 0);
}
+
template <typename Type>
static inline Type *hb_object_create (void)
{
- Type *obj = (Type *) hb_object_header_t::create (sizeof (Type));
+ Type *obj = (Type *) calloc (1, sizeof (Type));
+
+ if (unlikely (!obj))
+ return obj;
+
+ hb_object_init (obj);
hb_object_trace (obj, HB_FUNC);
return obj;
}
template <typename Type>
-static inline bool hb_object_is_inert (const Type *obj)
+static inline void hb_object_init (Type *obj)
{
- return unlikely (obj->header.is_inert ());
+ obj->header.ref_count.init (1);
+ obj->header.user_data.init ();
}
template <typename Type>
-static inline Type *hb_object_reference (Type *obj)
+static inline bool hb_object_is_inert (const Type *obj)
{
- hb_object_trace (obj, HB_FUNC);
- obj->header.reference ();
- return obj;
+ return unlikely (obj->header.ref_count.is_inert ());
}
template <typename Type>
-static inline bool hb_object_destroy (Type *obj)
+static inline bool hb_object_is_valid (const Type *obj)
{
- hb_object_trace (obj, HB_FUNC);
- return obj->header.destroy ();
+ return likely (obj->header.ref_count.is_valid ());
}
template <typename Type>
-static inline void hb_object_lock (Type *obj)
+static inline Type *hb_object_reference (Type *obj)
{
hb_object_trace (obj, HB_FUNC);
- return obj->header.lock ();
+ if (unlikely (!obj || hb_object_is_inert (obj)))
+ return obj;
+ assert (hb_object_is_valid (obj));
+ obj->header.ref_count.inc ();
+ return obj;
}
template <typename Type>
-static inline void hb_object_unlock (Type *obj)
+static inline bool hb_object_destroy (Type *obj)
{
hb_object_trace (obj, HB_FUNC);
- return obj->header.unlock ();
+ if (unlikely (!obj || hb_object_is_inert (obj)))
+ return false;
+ assert (hb_object_is_valid (obj));
+ if (obj->header.ref_count.dec () != 1)
+ return false;
+
+ obj->header.ref_count.finish (); /* Do this before user_data */
+ obj->header.user_data.finish ();
+ return true;
}
template <typename Type>
static inline bool hb_object_set_user_data (Type *obj,
hb_destroy_func_t destroy,
hb_bool_t replace)
{
- return obj->header.set_user_data (key, data, destroy, replace);
+ if (unlikely (!obj || hb_object_is_inert (obj)))
+ return false;
+ assert (hb_object_is_valid (obj));
+ return obj->header.user_data.set (key, data, destroy, replace);
}
template <typename Type>
static inline void *hb_object_get_user_data (Type *obj,
hb_user_data_key_t *key)
{
- return obj->header.get_user_data (key);
+ if (unlikely (!obj || hb_object_is_inert (obj)))
+ return NULL;
+ assert (hb_object_is_valid (obj));
+ return obj->header.user_data.get (key);
}
projects / platform / upstream / harfbuzz.git / blobdiff