/* XXX make this thread-safe, somehow! */
-typedef struct {
+struct hb_user_data_t {
+ hb_user_data_key_t *key;
void *data;
hb_destroy_func_t destroy;
+ inline bool operator == (hb_user_data_key_t *other_key) const { return key == other_key; }
+ inline bool operator == (hb_user_data_t &other) const { return key == other.key; }
+
void finish (void) { if (destroy) destroy (data); }
-} hb_user_data_t;
+};
struct hb_user_data_array_t {
- hb_map_t<hb_user_data_key_t *, hb_user_data_t> map;
+ hb_set_t<hb_user_data_t> items;
inline bool set (hb_user_data_key_t *key,
void * data,
hb_destroy_func_t destroy)
{
+ if (!key)
+ return false;
if (!data && !destroy) {
- map.unset (key);
+ items.remove (key);
return true;
}
- if (!key)
- return false;
- hb_user_data_t user_data = {data, destroy};
- return map.set (key, user_data);
+ hb_user_data_t user_data = {key, data, destroy};
+ return items.insert (user_data);
}
inline void *get (hb_user_data_key_t *key) {
- hb_user_data_t *user_data = map.get (key);
+ hb_user_data_t *user_data = items.get (key);
return user_data ? user_data->data : NULL;
}
- void finish (void) { map.finish (); }
+ void finish (void) { items.finish (); }
};
Type *array;
Type static_array[StaticSize];
- void finish (void) { for (unsigned i = 0; i < len; i++) array[i].finish (); }
-
inline Type& operator [] (unsigned int i)
{
return array[i];
struct hb_array_t : hb_static_array_t<Type, 2> {};
-template <typename Key, typename Value>
-struct hb_map_t
+template <typename item_t>
+struct hb_set_t
{
- struct item_t {
- Key key;
- /* unsigned int hash; */
- Value value;
-
- void finish (void) { value.finish (); }
- };
-
hb_array_t <item_t> items;
private:
template <typename T>
- inline item_t *find (T key) {
+ inline item_t *find (T v) {
for (unsigned int i = 0; i < items.len; i++)
- if (items[i].key == key)
+ if (items[i] == v)
return &items[i];
return NULL;
}
public:
template <typename T>
- inline bool set (T key,
- Value &value)
+ inline bool insert (T v)
{
- item_t *item;
- item = find (key);
+ item_t *item = find (v);
if (item)
item->finish ();
else
item = items.push ();
if (unlikely (!item)) return false;
- item->key = key;
- item->value = value;
+ *item = v;
return true;
}
- inline void unset (Key &key)
+ template <typename T>
+ inline void remove (T v)
{
- item_t *item;
- item = find (key);
+ item_t *item = find (v);
if (!item) return;
item->finish ();
}
template <typename T>
- inline Value *get (T key)
+ inline item_t *get (T v)
{
- item_t *item = find (key);
- return item ? &item->value : NULL;
+ return find (v);
+ }
+
+ void finish (void) {
+ for (unsigned i = 0; i < items.len; i++)
+ items[i].finish ();
}
- void finish (void) { items.finish (); }
};
g_assert (o->get_user_data (obj, &key[i]) == &data[i]);
for (i = 100; i < 1000; i++)
g_assert (o->set_user_data (obj, &key[i], NULL, NULL));
+ for (i = 2; i < 100; i++)
+ g_assert (o->get_user_data (obj, &key[i]) == &data[i]);
+ for (i = 100; i < 1000; i++)
+ g_assert (!o->get_user_data (obj, &key[i]));
g_assert_cmpuint (global_data, ==, 900);