GSList* roster_get_group(const char *const group, roster_ord_t order) { assert(roster != NULL); GSList *result = NULL; GHashTableIter iter; gpointer key; gpointer value; GCompareFunc cmp_func; if (order == ROSTER_ORD_PRESENCE) { cmp_func = (GCompareFunc) _compare_presence; } else { cmp_func = (GCompareFunc) _compare_name; } g_hash_table_iter_init(&iter, roster->contacts); while (g_hash_table_iter_next(&iter, &key, &value)) { GSList *groups = p_contact_groups(value); if (group == NULL) { if (groups == NULL) { result = g_slist_insert_sorted(result, value, cmp_func); } } else { while (groups) { if (strcmp(groups->data, group) == 0) { result = g_slist_insert_sorted(result, value, cmp_func); break; } groups = g_slist_next(groups); } } } // return all contact structs return result; }
gboolean mcap_create_mdl(struct mcap_mcl *mcl, uint8_t mdepid, uint8_t conf, mcap_mdl_operation_conf_cb connect_cb, gpointer user_data, GDestroyNotify destroy, GError **err) { struct mcap_mdl *mdl; struct mcap_mdl_op_cb *con; mcap_md_create_mdl_req *cmd; uint16_t id; id = generate_mdlid(mcl); if (!id) { g_set_error(err, MCAP_ERROR, MCAP_ERROR_FAILED, "Not more mdlids available"); return FALSE; } mdl = g_new0(struct mcap_mdl, 1); mdl->mcl = mcap_mcl_ref(mcl); mdl->mdlid = id; mdl->mdep_id = mdepid; mdl->state = MDL_WAITING; con = g_new0(struct mcap_mdl_op_cb, 1); con->mdl = mcap_mdl_ref(mdl); con->cb.op_conf = connect_cb; con->destroy = destroy; con->user_data = user_data; cmd = create_mdl_req(id, mdepid, conf); if (!mcap_send_std_opcode(mcl, cmd, sizeof(mcap_md_create_mdl_req), err)) { mcap_mdl_unref(con->mdl); g_free(con); g_free(cmd); return FALSE; } mcl->state = MCL_ACTIVE; mcl->priv_data = con; mcl->mdls = g_slist_insert_sorted(mcl->mdls, mcap_mdl_ref(mdl), compare_mdl); mcl->tid = g_timeout_add_seconds(RESPONSE_TIMER, wait_response_timer, mcl); return TRUE; }
void p_add_proto_data(frame_data *fd, int proto, void *proto_data) { frame_proto_data *p1 = wmem_alloc(wmem_file_scope(), sizeof(frame_proto_data)); p1->proto = proto; p1->proto_data = proto_data; /* Add it to the GSLIST */ fd -> pfd = g_slist_insert_sorted(fd -> pfd, (gpointer *)p1, p_compare); }
int connman_session_policy_register(struct connman_session_policy *policy) { DBG("name %s", policy->name); if (policy->create == NULL || policy->destroy == NULL) return -EINVAL; policy_list = g_slist_insert_sorted(policy_list, policy, compare_priority); probe_policy(policy); return 0; }
static int pc_dimm_built_list(Object *obj, void *opaque) { GSList **list = opaque; if (object_dynamic_cast(obj, TYPE_PC_DIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { /* only realized DIMMs matter */ *list = g_slist_insert_sorted(*list, dev, pc_dimm_addr_sort); } } object_child_foreach(obj, pc_dimm_built_list, opaque); return 0; }
GSList *windows_get_sorted(void) { GSList *tmp, *sorted; sorted = NULL; for (tmp = windows; tmp != NULL; tmp = tmp->next) { WINDOW_REC *rec = tmp->data; sorted = g_slist_insert_sorted(sorted, rec, (GCompareFunc) window_refnum_cmp); } return sorted; }
gboolean eom_plugin_engine_activate_plugin (EomPluginInfo *info) { eom_debug (DEBUG_PLUGINS); g_return_val_if_fail (info != NULL, FALSE); if (!info->available) return FALSE; if (info->active) return TRUE; if (eom_plugin_engine_activate_plugin_real (info)) { GSList *list; /* Update plugin state */ info->active = TRUE; list = active_plugins; while (list != NULL) { if (strcmp (info->location, (gchar *)list->data) == 0) { g_warning ("Plugin '%s' is already active.", info->name); return TRUE; } list = g_slist_next (list); } active_plugins = g_slist_insert_sorted (active_plugins, g_strdup (info->location), (GCompareFunc)strcmp); GArray *array; GSList *l; array = g_array_new (TRUE, TRUE, sizeof (gchar *)); for (l = active_plugins; l; l = l->next) { array = g_array_append_val (array, l->data); } g_settings_set_strv (eom_plugin_engine_settings, EOM_CONF_PLUGINS_ACTIVE_PLUGINS, (const gchar **) array->data); g_array_free (array, TRUE); return TRUE; } return FALSE; }
void add_timeout_intern(int value_msec, int interval_msec, void (*_callback)(), void* arg, timeout* t) { t->interval_msec = interval_msec; t->_callback = _callback; t->arg = arg; struct timespec cur_time; clock_gettime(CLOCK_MONOTONIC, &cur_time); t->timeout_expires = add_msec_to_timespec(cur_time, value_msec); int can_align = 0; if (interval_msec > 0 && !t->multi_timeout) can_align = align_with_existing_timeouts(t); if (!can_align) timeout_list = g_slist_insert_sorted(timeout_list, t, compare_timeouts); }
GSList* form_get_field_values_sorted(FormField *field) { GSList *sorted = NULL; GSList *curr = field->values; while (curr) { char *value = curr->data; if (value) { sorted = g_slist_insert_sorted(sorted, value, (GCompareFunc)g_strcmp0); } curr = g_slist_next(curr); } return sorted; }
GSList* form_get_non_form_type_fields_sorted(DataForm *form) { GSList *sorted = NULL; GSList *curr = form->fields; while (curr) { FormField *field = curr->data; if (g_strcmp0(field->var, "FORM_TYPE") != 0) { sorted = g_slist_insert_sorted(sorted, field, (GCompareFunc)_field_compare_by_var); } curr = g_slist_next(curr); } return sorted; }
RESULT test_slist_insert_sorted () { GSList *list = g_slist_prepend (NULL, "a"); list = g_slist_append (list, "aaa"); /* insert at the middle */ list = g_slist_insert_sorted (list, "aa", compare); if (strcmp ("aa", list->next->data)) return FAILED("insert_sorted failed #1"); /* insert at the beginning */ list = g_slist_insert_sorted (list, "", compare); if (strcmp ("", list->data)) return FAILED ("insert_sorted failed #2"); /* insert at the end */ list = g_slist_insert_sorted (list, "aaaa", compare); if (strcmp ("aaaa", g_slist_last (list)->data)) return FAILED ("insert_sorted failed #3"); g_slist_free (list); return OK; }
static gboolean build_langs_list (const gchar *key, const gchar *value, gpointer data) { CeditSpellCheckerLanguage *lang = g_new (CeditSpellCheckerLanguage, 1); lang->abrev = g_strdup (key); lang->name = g_strdup (value); available_languages = g_slist_insert_sorted (available_languages, lang, (GCompareFunc)lang_cmp); return FALSE; }
GSList * roster_get_contacts(void) { GSList *result = NULL; GHashTableIter iter; gpointer key; gpointer value; g_hash_table_iter_init(&iter, contacts); while (g_hash_table_iter_next(&iter, &key, &value)) { result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_contacts); } // resturn all contact structs return result; }
static GSList *get_sticky_windows_sorted(MAIN_WINDOW_REC *mainwin) { GSList *tmp, *list; list = NULL; for (tmp = windows; tmp != NULL; tmp = tmp->next) { WINDOW_REC *rec = tmp->data; if (WINDOW_GUI(rec)->sticky && WINDOW_MAIN(rec) == mainwin) { list = g_slist_insert_sorted(list, rec, (GCompareFunc) window_refnum_cmp); } } return list; }
static int add_queue(struct cpu_info *ci, struct if_queue_info *qi) { struct cpuset *set = ci->ci_cpuset; ci->ci_num_queues++; set->cs_cpu_lru_list = g_slist_remove_link(set->cs_cpu_lru_list, set->cs_cpu_lru_list); set->cs_cpu_lru_list = g_slist_insert_sorted(set->cs_cpu_lru_list, ci, cpu_cmp); ci->ci_queues = g_slist_append(ci->ci_queues, qi); return 0; }
void register_conversation_table(const int proto_id, gboolean hide_ports, tap_packet_cb conv_packet_func, tap_packet_cb hostlist_func) { register_ct_t *table; table = g_new(register_ct_t,1); table->hide_ports = hide_ports; table->proto_id = proto_id; table->conv_func = conv_packet_func; table->host_func = hostlist_func; table->conv_gui_init = NULL; table->host_gui_init = NULL; registered_ct_tables = g_slist_insert_sorted(registered_ct_tables, table, insert_sorted_by_table_name); }
void htmlview_add_item (itemPtr item) { htmlChunkPtr chunk; debug1 (DEBUG_HTML, "HTML view: adding \"%s\"", item_get_title (item)); chunk = g_new0 (struct htmlChunk, 1); chunk->id = item->id; g_hash_table_insert (htmlView_priv.chunkHash, GUINT_TO_POINTER (item->id), chunk); htmlView_priv.orderedChunks = g_slist_insert_sorted (htmlView_priv.orderedChunks, chunk, htmlview_chunk_sort); if (!item_get_description (item) || (0 == strlen (item_get_description (item)))) htmlView_priv.missingContent++; }
void gimp_preview_cache_add (GSList **plist, TempBuf *buf) { #ifdef PREVIEW_CACHE_DEBUG g_print ("gimp_preview_cache_add: %d x %d\n", buf->width, buf->height); preview_cache_print (*plist); #endif if (g_slist_length (*plist) >= MAX_CACHE_PREVIEWS) { preview_cache_remove_smallest (plist); } *plist = g_slist_insert_sorted (*plist, buf, preview_cache_compare); }
static gpointer res_thread(gpointer data) { PDNS_RECORD dr = NULL; int type = DNS_TYPE_SRV; DNS_STATUS ds; GaimSrvQueryData *query_data = data; ds = MyDnsQuery_UTF8(query_data->query, type, DNS_QUERY_STANDARD, NULL, &dr, NULL); if (ds != ERROR_SUCCESS) { gchar *msg = g_win32_error_message(ds); query_data->error_message = g_strdup_printf("Couldn't look up SRV record. %s (%lu).\n", msg, ds); g_free(msg); } else { PDNS_RECORD dr_tmp; GSList *lst = NULL; DNS_SRV_DATA *srv_data; GaimSrvResponse *srvres; for (dr_tmp = dr; dr_tmp != NULL; dr_tmp = dr_tmp->pNext) { /* Discard any incorrect entries. I'm not sure if this is necessary */ if (dr_tmp->wType != type || strcmp(dr_tmp->pName, query_data->query) != 0) { continue; } srv_data = &dr_tmp->Data.SRV; srvres = g_new0(GaimSrvResponse, 1); strncpy(srvres->hostname, srv_data->pNameTarget, 255); srvres->hostname[255] = '\0'; srvres->pref = srv_data->wPriority; srvres->port = srv_data->wPort; srvres->weight = srv_data->wWeight; lst = g_slist_insert_sorted(lst, srvres, responsecompare); } MyDnsRecordListFree(dr, DnsFreeRecordList); query_data->results = lst; } /* back to main thread */ /* Note: this should *not* be attached to query_data->handle - it will cause leakage */ g_idle_add(res_main_thread_cb, query_data); g_thread_exit(NULL); return NULL; }
void matecomponent_activation_base_service_registry_add (const MateComponentActivationBaseServiceRegistry *registry, int priority, gpointer user_data) { RegistryInfo *new_ri; g_return_if_fail (registry); new_ri = g_new (RegistryInfo, 1); new_ri->priority = priority; new_ri->registry = registry; new_ri->user_data = user_data; registries = g_slist_insert_sorted (registries, new_ri, ri_compare); }
GSList* roster_get_contacts_online(void) { GSList *result = NULL; GHashTableIter iter; gpointer key; gpointer value; g_hash_table_iter_init(&iter, contacts); while (g_hash_table_iter_next(&iter, &key, &value)) { if(strcmp(p_contact_presence(value), "offline")) result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_contacts); } // return all contact structs return result; }
static gboolean cfg_lexer_include_file_add(CfgLexer *self, const gchar *fn) { CfgIncludeLevel *level; level = &self->include_stack[self->include_depth]; level->include_type = CFGI_FILE; level->file.files = g_slist_insert_sorted(level->file.files, strdup(fn), (GCompareFunc) strcmp); msg_debug("Adding include file", evt_tag_str("filename", fn), evt_tag_int("depth", self->include_depth)); return TRUE; }
irc_user_t *irc_user_new( irc_t *irc, const char *nick ) { irc_user_t *iu = g_new0( irc_user_t, 1 ); iu->irc = irc; iu->nick = g_strdup( nick ); iu->user = iu->host = iu->fullname = iu->nick; iu->key = g_strdup( nick ); nick_lc( iu->key ); /* Using the hash table for speed and irc->users for easy iteration through the list (since the GLib API doesn't have anything sane for that.) */ g_hash_table_insert( irc->nick_user_hash, iu->key, iu ); irc->users = g_slist_insert_sorted( irc->users, iu, irc_user_cmp ); return iu; }
static GSList * append_nmt_devices_for_virtual_devices (GSList *nmt_devices, const GPtrArray *connections) { NmtConnectDevice *nmtdev = NULL; int i; GHashTable *devices_by_name; char *name; NMConnection *conn; NmtConnectConnection *nmtconn; int sort_order; devices_by_name = g_hash_table_new (g_str_hash, g_str_equal); for (i = 0; i < connections->len; i++) { conn = connections->pdata[i]; sort_order = get_sort_order_for_connection (conn); if (sort_order == -1) continue; name = nm_connection_get_virtual_device_description (conn); if (name) nmtdev = g_hash_table_lookup (devices_by_name, name); if (nmtdev) g_free (name); else { nmtdev = g_slice_new0 (NmtConnectDevice); nmtdev->name = name ? name : g_strdup ("Unknown"); nmtdev->sort_order = sort_order; g_hash_table_insert (devices_by_name, nmtdev->name, nmtdev); nmt_devices = g_slist_prepend (nmt_devices, nmtdev); } nmtconn = g_slice_new0 (NmtConnectConnection); nmtconn->name = nm_connection_get_id (conn); nmtconn->conn = g_object_ref (conn); nmtdev->conns = g_slist_insert_sorted (nmtdev->conns, nmtconn, sort_connections); } g_hash_table_destroy (devices_by_name); return nmt_devices; }
static void list_encap_types(void) { int i; struct string_elem *encaps; GSList *list = NULL; encaps = g_malloc(sizeof(struct string_elem) * WTAP_NUM_ENCAP_TYPES); fprintf(stderr, "editcap: The available encapsulation types for the \"-T\" flag are:\n"); for (i = 0; i < WTAP_NUM_ENCAP_TYPES; i++) { encaps[i].sstr = wtap_encap_short_string(i); if (encaps[i].sstr != NULL) { encaps[i].lstr = wtap_encap_string(i); list = g_slist_insert_sorted(list, &encaps[i], string_compare); } } g_slist_foreach(list, string_elem_print, NULL); g_slist_free(list); g_free(encaps); }
static void list_capture_types(void) { int i; struct string_elem *captypes; GSList *list = NULL; captypes = g_malloc(sizeof(struct string_elem) * WTAP_NUM_FILE_TYPES); fprintf(stderr, "editcap: The available capture file types for the \"-F\" flag are:\n"); for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) { if (wtap_dump_can_open(i)) { captypes[i].sstr = wtap_file_type_short_string(i); captypes[i].lstr = wtap_file_type_string(i); list = g_slist_insert_sorted(list, &captypes[i], string_compare); } } g_slist_foreach(list, string_elem_print, NULL); g_slist_free(list); g_free(captypes); }
GSList* roster_get_contacts_by_presence(const char *const presence) { GSList *result = NULL; GHashTableIter iter; gpointer key; gpointer value; g_hash_table_iter_init(&iter, contacts); while (g_hash_table_iter_next(&iter, &key, &value)) { PContact contact = (PContact)value; if (g_strcmp0(p_contact_presence(contact), presence) == 0) { result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_contacts); } } // return all contact structs return result; }
/** * Insert `key' into the slist. */ void slist_insert_sorted(slist_t *slist, void *key, GCompareFunc func) { slist_check(slist); g_assert(1 == slist->refcount); g_assert(func); slist->head = g_slist_insert_sorted(slist->head, key, func); if (slist->tail) { slist->tail = g_slist_last(slist->tail); } else { slist->tail = slist->head; } slist->length++; slist->stamp++; slist_regression(slist); }
/** * connman_network_driver_register: * @driver: network driver definition * * Register a new network driver * * Returns: %0 on success */ int connman_network_driver_register(struct connman_network_driver *driver) { GSList *list; DBG("driver %p name %s", driver, driver->name); for (list = driver_list; list; list = list->next) { struct connman_network_driver *tmp = list->data; if (tmp->type == driver->type) return -EALREADY; } driver_list = g_slist_insert_sorted(driver_list, driver, compare_priority); probe_driver(driver); return 0; }
static void statusbar_resize_items(STATUSBAR_REC *bar, int max_width) { GSList *tmp, *prior_sorted; int width; /* first give items their max. size */ prior_sorted = NULL; width = 0; for (tmp = bar->items; tmp != NULL; tmp = tmp->next) { SBAR_ITEM_REC *rec = tmp->data; rec->func(rec, TRUE); rec->size = rec->max_size; if (rec->size > 0) { width += rec->max_size; prior_sorted = g_slist_insert_sorted(prior_sorted, rec, (GCompareFunc) sbar_item_cmp); } } if (width > max_width) { /* too big, start shrinking from items with lowest priority and shrink until everything fits or until we've shrinked all items. */ width = statusbar_shrink_to_min(prior_sorted, width, max_width); if (width > max_width) { /* still need to shrink, remove the items with lowest priority until everything fits to screen */ statusbar_shrink_forced(prior_sorted, width, max_width); } } g_slist_free(prior_sorted); }