int remove_parent_from_host(host *hst, host *parent) { if (hst->parent_hosts) { g_tree_remove(hst->parent_hosts, parent->name); } if (parent->child_hosts) { g_tree_remove(parent->child_hosts, hst->name); } return 0; }
static int8_t scheduleTimeoutEventLockHeld(dispatcher_t* disp, entity_context_t* ent_context) { if (disp->fd_flag[ent_context->fd] != 1) return -1; gboolean rc = g_tree_remove(disp->registered_timeouts, &(ent_context->scheduled)); ent_context->scheduled.tv_sec = ent_context->to_be_scheduled.tv_sec; ent_context->scheduled.tv_usec = ent_context->to_be_scheduled.tv_usec; struct timeval* key = newTimevalKey(&(ent_context->scheduled)); if (key) { while (1) { entity_context_t* tmp_ent_ctx = g_tree_lookup( disp->registered_timeouts, key); if (!tmp_ent_ctx) break; key->tv_usec += 1; } g_tree_insert(disp->registered_timeouts, key, ent_context); ent_context->to_be_scheduled.tv_sec = 0; ent_context->to_be_scheduled.tv_usec = 0; //recalculate the epoll_timeout GTraverseFunc update_epoll_timeout = updateEpollTimeout; g_tree_foreach(disp->registered_timeouts, update_epoll_timeout, disp); //traverse only one element.require MIN(timeout) return 1; } return -1; }
/** * PRE: * - The base must be owned by the current thread * - it must be opened only once and locked only once * - the cache-wide lock must be owned by the current thread * * POST: * - The base is returned to the FREE list * - the base is not owned by any thread * - The cache-wide lock is still owned */ static void _expire_base(sqlx_cache_t *cache, sqlx_base_t *b) { hashstr_t *n = b->name; gpointer handle = b->handle; sqlx_base_debug("FREEING", b); EXTRA_ASSERT(b->owner != NULL); EXTRA_ASSERT(b->count_open == 0); EXTRA_ASSERT(b->status == SQLX_BASE_USED); sqlx_base_move_to_list(cache, b, SQLX_BASE_CLOSING); /* the base is for the given thread, it is time to REALLY close it. * But this can take a lot of time. So we can release the pool, * free the handle and unlock the cache */ g_cond_signal(b->cond); g_mutex_unlock(&cache->lock); if (cache->close_hook) cache->close_hook(handle); g_mutex_lock(&cache->lock); b->handle = NULL; b->owner = NULL; b->name = NULL; b->count_open = 0; b->last_update.tv_sec = b->last_update.tv_usec = 0; sqlx_base_move_to_list(cache, b, SQLX_BASE_FREE); g_tree_remove(cache->bases_by_name, n); g_free(n); }
void mc_event_group_del (const gchar * event_group_name) { if (mc_event_grouplist != NULL && event_group_name != NULL) g_tree_remove (mc_event_grouplist, (gconstpointer) event_group_name); }
gboolean ibus_hotkey_profile_remove_hotkey_by_event (IBusHotkeyProfile *profile, GQuark event) { IBusHotkeyProfilePrivate *priv; priv = IBUS_HOTKEY_PROFILE_GET_PRIVATE (profile); gint i; IBusHotkeyEvent *p = NULL; for ( i = 0; i < priv->events->len; i++) { p = &g_array_index (priv->events, IBusHotkeyEvent, i); if (p->event == event) break; } if (p == NULL || p->event != event) return FALSE; GList *list; for (list = p->hotkeys; list != NULL; list = list->next) { g_tree_remove (priv->hotkeys, (IBusHotkey *)list->data); } g_list_free (p->hotkeys); g_array_remove_index_fast (priv->events, i); return TRUE; }
/** * pka_subscription_remove_source: * @subscription: A #PkaSubscription. * @context: A #PkaContext. * @source: A #PkaSource. * @error: A location for #GError, or %NULL. * * Removes @source from @subscription. * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. * Side effects: None. */ gboolean pka_subscription_remove_source (PkaSubscription *subscription, /* IN */ PkaContext *context, /* IN */ PkaSource *source, /* IN */ GError **error) /* OUT */ { gboolean ret = FALSE; gint key; g_return_val_if_fail(subscription != NULL, FALSE); g_return_val_if_fail(context != NULL, FALSE); g_return_val_if_fail(PKA_IS_SOURCE(source), FALSE); ENTRY; if (!IS_AUTHORIZED(context, MODIFY_SUBSCRIPTION, subscription)) { g_set_error(error, PKA_CONTEXT_ERROR, PKA_CONTEXT_ERROR_NOT_AUTHORIZED, "Not authoraized to remove source %d from subscription %d.", pka_source_get_id(source), subscription->id); GOTO(failed); } key = pka_source_get_id(source); pka_source_remove_subscription(source, subscription); g_static_rw_lock_writer_lock(&subscription->rw_lock); g_tree_remove(subscription->sources, &key); g_static_rw_lock_writer_unlock(&subscription->rw_lock); ret = TRUE; failed: RETURN(ret); }
/* removes AND DESTROYS the named link from catalog */ void links_catalog_remove(const link_id_t *key) { g_assert(all_links); g_assert(key); g_tree_remove (all_links, key); }
static void __agent_schedule_abs(struct ice_agent *ag, const struct timeval *tv) { struct timeval nxt; long long diff; if (!ag) { ilog(LOG_ERR, "ice ag is NULL"); return; } nxt = *tv; mutex_lock(&ice_agents_timers_lock); if (ag->last_run.tv_sec) { /* make sure we don't run more often than we should */ diff = timeval_diff(&nxt, &ag->last_run); if (diff < TIMER_RUN_INTERVAL * 1000) timeval_add_usec(&nxt, TIMER_RUN_INTERVAL * 1000 - diff); } if (ag->next_check.tv_sec && timeval_cmp(&ag->next_check, &nxt) <= 0) goto nope; /* already scheduled sooner */ if (!g_tree_remove(ice_agents_timers, ag)) obj_hold(ag); /* if it wasn't removed, we make a new reference */ ag->next_check = nxt; g_tree_insert(ice_agents_timers, ag, ag); cond_broadcast(&ice_agents_timers_cond); nope: mutex_unlock(&ice_agents_timers_lock); }
void wavegen_noteoff (Machine *mach, int notenum) { WaveGen *wavegen = WAVEGEN (mach); /* TODO: BAD STUFF: doesn't free the WaveGenNote! */ g_tree_remove (wavegen->notes, GINT_TO_POINTER (notenum)); }
static void oscats_administrand_dispose (GObject *object) { OscatsAdministrand *self = OSCATS_ADMINISTRAND(object); G_OBJECT_CLASS(oscats_administrand_parent_class)->dispose(object); if (self->characteristics) g_object_unref(self->characteristics); self->characteristics = NULL; g_tree_remove(administrands, self); }
static void tree_remove_watch_directory(struct watch_directory *directory) { G_GNUC_UNUSED bool found = g_tree_remove(inotify_directories, GINT_TO_POINTER(directory->descriptor)); assert(found); }
static void keyfile_to_tree (GKeyfileSettingsBackend *kfsb, GTree *tree, GKeyFile *keyfile, gboolean dup_check) { gchar **groups; gint i; groups = g_key_file_get_groups (keyfile, NULL); for (i = 0; groups[i]; i++) { gboolean is_root_group; gchar **keys; gint j; is_root_group = g_strcmp0 (kfsb->root_group, groups[i]) == 0; /* reject group names that will form invalid key names */ if (!is_root_group && (g_str_has_prefix (groups[i], "/") || g_str_has_suffix (groups[i], "/") || strstr (groups[i], "//"))) continue; keys = g_key_file_get_keys (keyfile, groups[i], NULL, NULL); g_assert (keys != NULL); for (j = 0; keys[j]; j++) { gchar *path, *value; /* reject key names with slashes in them */ if (strchr (keys[j], '/')) continue; if (is_root_group) path = g_strdup_printf ("%s%s", kfsb->prefix, keys[j]); else path = g_strdup_printf ("%s%s/%s", kfsb->prefix, groups[i], keys[j]); value = g_key_file_get_value (keyfile, groups[i], keys[j], NULL); if (dup_check && g_strcmp0 (g_tree_lookup (tree, path), value) == 0) { g_tree_remove (tree, path); g_free (value); g_free (path); } else g_tree_insert (tree, path, value); } g_strfreev (keys); } g_strfreev (groups); }
static void msn_buddy_data_free( bee_user_t *bu ) { struct msn_data *md = bu->ic->proto_data; struct msn_buddy_data *bd = bu->data; g_free( bd->cid ); g_free( bd ); g_tree_remove( md->domaintree, bu->handle ); }
static void on_remove(breakpoint *bp) { /* remove marker */ markers_remove_breakpoint(bp); /* remove from breakpoints tab */ bptree_remove_breakpoint(bp); /* remove from internal storage */ GTree *tree = g_hash_table_lookup(files, bp->file); g_tree_remove(tree, GINT_TO_POINTER(bp->line)); }
static void deRegisterInterface(PINTERFACE pif) { PPARSEINFO pParseInfo=(PPARSEINFO)gScanner->user_data; /* Remove the interface from our list */ g_ptr_array_remove(pParseInfo->pInterfaceArray, (gpointer) pif); /* Any found interface was registered as a new type so it can be used in other classes. */ g_tree_remove(pParseInfo->pSymbolTree, pif->pSymbolIFace); g_scanner_scope_remove_symbol(gScanner, ID_SCOPE, pif->pSymbolIFace->chrSymbolName); /* For legacy support and convenience we automatically registered a pointer type to the interface. */ g_tree_remove(pParseInfo->pSymbolTree, pif->pSymbolIFacePtr); g_scanner_scope_remove_symbol(gScanner, ID_SCOPE, pif->pSymbolIFacePtr->chrSymbolName); /* We don't clean up. Looking at the whole mess with string dupes and stuff in side the structs I just decided to use a GC instead... */ }
static void C(struct blk_io_trace *t, void *data) { DECL_ASSIGN_I2C(i2c,data); if(g_tree_lookup(i2c->is, &t->sector)!=NULL) { g_tree_remove(i2c->is, &t->sector); oio_change(i2c, t, FALSE); } }
void mc_event_destroy (const gchar * event_group_name, const gchar * event_name) { GTree *event_group; if (mc_event_grouplist == NULL || event_group_name == NULL || event_name == NULL) return; event_group = mc_event_get_event_group_by_name (event_group_name, FALSE, NULL); g_tree_remove (event_group, (gconstpointer) event_name); }
static gboolean mailbox_clear_recent(uint64_t *uid, MessageInfo *msginfo, T M) { msginfo->flags[IMAP_FLAG_RECENT] = 0; gpointer value; gpointer orig_key; if (g_tree_lookup_extended(M->recent_queue, uid, &orig_key, &value)) { g_tree_remove(M->recent_queue, orig_key); mempool_push(M->pool, orig_key, sizeof(uint64_t)); } return FALSE; }
void ice_thread_run(void *p) { struct ice_agent *ag; struct call *call; long long sleeptime; struct timeval tv; mutex_lock(&ice_agents_timers_lock); while (!g_shutdown) { gettimeofday(&g_now, NULL); /* lock our list and get the first element */ ag = g_tree_find_first(ice_agents_timers, NULL, NULL); /* scheduled to run? if not, we just go to sleep, otherwise we remove it from the tree, * steal the reference and run it */ if (!ag) goto sleep; if (timeval_cmp(&g_now, &ag->next_check) < 0) goto sleep; g_tree_remove(ice_agents_timers, ag); ZERO(ag->next_check); ag->last_run = g_now; mutex_unlock(&ice_agents_timers_lock); /* this agent is scheduled to run right now */ /* lock the call */ call = ag->call; log_info_ice_agent(ag); rwlock_lock_r(&call->master_lock); /* and run our checks */ __do_ice_checks(ag); /* finally, release our reference and start over */ log_info_clear(); rwlock_unlock_r(&call->master_lock); obj_put(ag); mutex_lock(&ice_agents_timers_lock); continue; sleep: /* figure out how long we should sleep */ sleeptime = ag ? timeval_diff(&ag->next_check, &g_now) : 100000; sleeptime = MIN(100000, sleeptime); /* 100 ms at the most */ tv = g_now; timeval_add_usec(&tv, sleeptime); cond_timedwait(&ice_agents_timers_cond, &ice_agents_timers_lock, &tv); continue; } mutex_unlock(&ice_agents_timers_lock); }
/** * @brief Clears the contents of a GTree * * @param tree the tree to remove all elements from */ void g_tree_clear(GTree* tree) { GList* keys = NULL; GList* iter = NULL; g_tree_foreach(tree, g_tree_collect, &keys); for(iter = keys; iter != NULL; iter = iter->next) g_tree_remove(tree, iter->data); g_list_free(keys); }
void b_free(void *p) { heap_entry *he = g_tree_lookup(heap_info, p); if (he != NULL) { bitmap_set_bits(bm, 0, he->bm_nbits, he->start_bm_idx); g_tree_remove(heap_info, p); free(he); } }
static void assert_compare_sample_and_delete_form_tree(GTree *tree, history_gluon_data_t *data_array, uint64_t num) { uint64_t i; for (i = 0; i < num; i++) { history_gluon_data_t *data = &data_array[i]; gboolean ret = g_tree_remove(g_gtree, make_sample_key(data)); cut_assert_equal_int(TRUE, ret); } }
static void __agent_deschedule(struct ice_agent *ag) { int ret; mutex_lock(&ice_agents_timers_lock); if (!ag->next_check.tv_sec) goto nope; /* already descheduled */ ret = g_tree_remove(ice_agents_timers, ag); ZERO(ag->next_check); if (ret) obj_put(ag); nope: mutex_unlock(&ice_agents_timers_lock); }
/**************************************************************************************************** * remove a single point ****************************************************************************************************/ void poi_set_remove_point(PoiSet * poi_set, int node_id, double lon, double lat) { struct Rect * rect = malloc(sizeof(struct Rect)); rect -> boundary[0] = lon; rect -> boundary[1] = lat; rect -> boundary[2] = lon; rect -> boundary[3] = lat; int del = r_r_tree_delete_rect(poi_set -> rtree, rect, node_id); free(rect); /* remove from binary tree */ g_tree_remove(poi_set -> points, &node_id); }
void prev_process_info__garbage_collector(cdtime_t tm) { /* {{{ */ prev_process_info__userdata_t userdata; GSList *cur; userdata.gl = NULL; userdata.tm = tm; g_tree_foreach(prev_process_info, prev_process_info__check_unused, &userdata); for(cur=userdata.gl; cur; cur = cur->next) { g_tree_remove(prev_process_info, cur->data); } g_slist_free(userdata.gl); } /* }}} */
int main(void) { GTree *t = g_tree_new((GCompareFunc)g_ascii_strcasecmp); g_tree_insert(t, "c", "Chicago"); printf("The tree height is %d\n", g_tree_height(t)); g_tree_insert(t, "b", "Boston"); g_tree_insert(t, "d", "Detroit"); printf("Height is now %d for %d nodes in the tree\n", g_tree_height(t), g_tree_nnodes(t)); g_tree_remove(t, "d"); printf("Height is now %d for %d nodes in the tree\n", g_tree_height(t), g_tree_nnodes(t)); g_tree_destroy(t); }
static void gslist_foreach_func (gpointer data, gpointer user_data) { RequestData **request_data_pointer = data; RequestData *request_data = *request_data_pointer; HTTPServer *http_server = user_data; GError *err = NULL; g_tree_remove (http_server->idle_queue, &(request_data->wakeup_time)); g_thread_pool_push (http_server->thread_pool, request_data_pointer, &err); if (err != NULL) { GST_FIXME ("Thread pool push error %s", err->message); g_error_free (err); } }
int main() { printf("Create a new GTree using g_tree_new_full().\n"); GTree *tree = g_tree_new_full((GCompareDataFunc)g_ascii_strcasecmp, NULL, (GDestroyNotify)destroy_key, (GDestroyNotify)destroy_val); printf("Add items to the tree.\n"); g_tree_insert(tree, "c", "Captain America"); g_tree_insert(tree, "i", "Iron Man"); g_tree_insert(tree, "h", "Hawk Eye"); g_tree_insert(tree, "s", "Spider Man"); printf("Tree height from g_tree_height(): %d\n", g_tree_height(tree)); printf("Number of nodes from g_tree_nnodes(): %d\n", g_tree_nnodes(tree)); printf("List the tree using g_tree_foreach() and a GTraverseFunc.\n"); printf("Tree Contents:\n"); g_tree_foreach(tree, (GTraverseFunc)print_iterator, NULL); printf("\n"); printf("Find items using g_tree_lookup().\n"); printf("The data at 'i' is '%s'\n", g_tree_lookup(tree, "i")); printf("%s\n\n", g_tree_lookup(tree, "d") ? "Unexpected value!!" : "No data found for 'd'"); printf("Find items using g_tree_search() and a GCompareFunc.\n"); gpointer val = g_tree_search(tree, (GCompareFunc)finder, NULL); printf("The value is %s\n\n", val); printf("Remove an item using g_tree_remove().\n"); g_tree_remove(tree, "h"); printf("Number of nodes is now: %d\n", g_tree_nnodes(tree)); printf("Tree Contents:\n"); g_tree_foreach(tree, (GTraverseFunc)print_iterator, NULL); printf("\n"); printf("Replacing 's', destroy functions will be called.\n"); g_tree_replace(tree, "s", "Storm"); printf("Number of nodes is now: %d\n", g_tree_nnodes(tree)); printf("Tree Contents:\n"); g_tree_foreach(tree, (GTraverseFunc)print_iterator, NULL); printf("\n"); printf("Stealing 'c' with g_tree_steal(), no drstroy functions now.\n"); g_tree_steal(tree, "c"); printf("Number of nodes is now: %d\n", g_tree_nnodes(tree)); printf("Tree Contents:\n"); g_tree_foreach(tree, (GTraverseFunc)print_iterator, NULL); printf("\n"); printf("Destroying the tree using g_tree_destroy().\n"); g_tree_destroy(tree); }
void timerthread_obj_deschedule(struct timerthread_obj *tt_obj) { if (!tt_obj) return; struct timerthread *tt = tt_obj->tt; mutex_lock(&tt->lock); if (!tt_obj->next_check.tv_sec) goto nope; /* already descheduled */ int ret = g_tree_remove(tt->tree, tt_obj); ZERO(tt_obj->next_check); if (ret) obj_put(tt_obj); nope: mutex_unlock(&tt->lock); }
/** * pka_subscription_remove_channel: * @subscription: A #PkaSubscription. * @context: A #PkaContext. * @channel: A #PkaChannel. * @error: A location #GError, or %NULL. * * Removes a channel and all of its sources from being monitored by the * subscription. * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. * Side effects: None. */ gboolean pka_subscription_remove_channel (PkaSubscription *subscription, /* IN */ PkaContext *context, /* IN */ PkaChannel *channel, /* IN */ GError **error) /* OUT */ { gboolean ret = FALSE; GList *sources = NULL; GList *iter; gint key; g_return_val_if_fail(subscription != NULL, FALSE); g_return_val_if_fail(context != NULL, FALSE); g_return_val_if_fail(PKA_IS_CHANNEL(channel), FALSE); ENTRY; if (!IS_AUTHORIZED(context, MODIFY_SUBSCRIPTION, subscription)) { g_set_error(error, PKA_CONTEXT_ERROR, PKA_CONTEXT_ERROR_NOT_AUTHORIZED, "Not authorized to remove channel %d from subscription %d.", pka_channel_get_id(channel), subscription->id); GOTO(failed); } g_signal_handlers_disconnect_by_func(channel, pka_subscription_channel_source_added, subscription); g_signal_handlers_disconnect_by_func(channel, pka_subscription_channel_source_removed, subscription); sources = pka_channel_get_sources(channel); for (iter = sources; iter; iter = iter->next) { if (!pka_subscription_remove_source(subscription, context, iter->data, NULL)) { WARNING(Subscription, "Could not remove source %d from subscription %d", pka_source_get_id(iter->data), subscription->id); } } g_list_foreach(sources, (GFunc)g_object_unref, NULL); g_list_free(sources); key = pka_channel_get_id(channel); g_static_rw_lock_writer_lock(&subscription->rw_lock); g_tree_remove(subscription->channels, &key); g_static_rw_lock_writer_unlock(&subscription->rw_lock); ret = TRUE; failed: RETURN(ret); }