/* Destroy all the items, called with items_lock locked */ static void wordsgame_destroy_all_items() { LettersItem *item; if (items!=NULL){ while (items->len>0) { item = g_ptr_array_index(items,0); g_ptr_array_remove_index_fast(items,0); wordsgame_destroy_item(item); } g_ptr_array_free (items, TRUE); items=NULL; } if (items2del!=NULL){ while (items2del->len>0) { item = g_ptr_array_index(items2del,0); g_ptr_array_remove_index_fast(items2del,0); wordsgame_destroy_item(item); } g_ptr_array_free (items2del, TRUE); items2del=NULL; } }
void gv_areas_delete_areas(GvAreas *areas, gint num_areas, gint *area_id) { GvArea *area; GvShapeChangeInfo change_info = {GV_CHANGE_DELETE, 0, NULL}; change_info.num_shapes = num_areas; change_info.shape_id = area_id; gv_data_changing(GV_DATA(areas), &change_info); if (num_areas == 1) { area = (GvArea*)g_ptr_array_remove_index_fast(areas->areas, *area_id); if (area) gv_area_delete(area); } else { /* Strategy: sort the area_id buffer and delete lines in descending order, so that indicies remain valid */ gint *id, i; id = g_memdup_type(area_id, gint, num_areas); g_sort_type(id, gint, num_areas); for (i=num_areas-1; i >= 0; --i) { area = (GvArea*)g_ptr_array_remove_index_fast(areas->areas, id[i]); if (area) gv_area_delete(area); } g_free(id); } gv_data_changed(GV_DATA(areas), &change_info); }
lfError lfDatabase::Load (const char *errcontext, const char *data, size_t data_size) { static GMarkupParser gmp = { _xml_start_element, _xml_end_element, _xml_text, NULL, NULL }; lfExtDatabase *This = static_cast<lfExtDatabase *> (this); /* Temporarily drop numeric format to "C" */ char *old_numeric = setlocale (LC_NUMERIC, NULL); old_numeric = strdup(old_numeric); setlocale(LC_NUMERIC,"C"); /* eek! GPtrArray does not have a method to insert a pointer into middle of the array... We have to remove the trailing NULL and re-append it after loading ... */ g_ptr_array_remove_index_fast (This->Mounts, This->Mounts->len - 1); g_ptr_array_remove_index_fast (This->Cameras, This->Cameras->len - 1); g_ptr_array_remove_index_fast (This->Lenses, This->Lenses->len - 1); lfParserData pd; memset (&pd, 0, sizeof (pd)); pd.db = This; GMarkupParseContext *mpc = g_markup_parse_context_new ( &gmp, (GMarkupParseFlags)0, &pd, NULL); GError *err = NULL; lfError e = g_markup_parse_context_parse (mpc, data, data_size, &err) ? LF_NO_ERROR : LF_WRONG_FORMAT; /* Display the parsing error as a warning */ if (e != LF_NO_ERROR) { gint line, col; g_markup_parse_context_get_position (mpc, &line, &col); g_warning ("%s:%d:%d: %s", errcontext, line, col, err->message); } g_markup_parse_context_free (mpc); /* Re-add the trailing NULL */ g_ptr_array_add (This->Mounts, NULL); g_ptr_array_add (This->Cameras, NULL); g_ptr_array_add (This->Lenses, NULL); /* Restore numeric format */ setlocale (LC_NUMERIC, old_numeric); free(old_numeric); return e; }
static void animator_frame_cb (AfTimeline *timeline, gdouble progress, gpointer user_data) { AfAnimator *animator; AfTransition *transition; guint i = 0; animator = (AfAnimator *) user_data; while (i < animator->transitions->len) { gdouble transition_progress; transition = g_ptr_array_index (animator->transitions, i); if (progress <= transition->from) { i++; continue; } transition_progress = progress - transition->from; transition_progress /= (transition->to - transition->from); transition_progress = CLAMP (transition_progress, 0.0, 1.0); af_transition_set_progress (transition, transition_progress, animator->user_data); if (progress >= transition->to) { g_ptr_array_remove_index_fast (animator->transitions, i); g_ptr_array_add (animator->finished_transitions, transition); } else i++; } if (progress == 1.0 && af_timeline_get_loop (timeline)) { /* Animation is about to begin again, * dump all finished transitions back. */ while (animator->finished_transitions->len > 0) { transition = g_ptr_array_remove_index_fast (animator->finished_transitions, 0); g_ptr_array_add (animator->transitions, transition); } } }
static void testWebContextSpellChecker(Test* test, gconstpointer) { WebKitWebContext* webContext = test->m_webContext.get(); // Check what happens if no spell checking language has been set. const gchar* const* currentLanguage = webkit_web_context_get_spell_checking_languages(webContext); g_assert(!currentLanguage); // Set the language to a specific one. GRefPtr<GPtrArray> languages = adoptGRef(g_ptr_array_new()); g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en_US"))); g_ptr_array_add(languages.get(), 0); webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata)); currentLanguage = webkit_web_context_get_spell_checking_languages(webContext); g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 1); g_assert_cmpstr(currentLanguage[0], ==, "en_US"); // Set the language string to list of valid languages. g_ptr_array_remove_index_fast(languages.get(), languages->len - 1); g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en_GB"))); g_ptr_array_add(languages.get(), 0); webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata)); currentLanguage = webkit_web_context_get_spell_checking_languages(webContext); g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 2); g_assert_cmpstr(currentLanguage[0], ==, "en_US"); g_assert_cmpstr(currentLanguage[1], ==, "en_GB"); // Try passing a wrong language along with good ones. g_ptr_array_remove_index_fast(languages.get(), languages->len - 1); g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("bd_WR"))); g_ptr_array_add(languages.get(), 0); webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata)); currentLanguage = webkit_web_context_get_spell_checking_languages(webContext); g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 2); g_assert_cmpstr(currentLanguage[0], ==, "en_US"); g_assert_cmpstr(currentLanguage[1], ==, "en_GB"); // Try passing a list with only wrong languages. languages = adoptGRef(g_ptr_array_new()); g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("bd_WR"))); g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("wr_BD"))); g_ptr_array_add(languages.get(), 0); webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata)); currentLanguage = webkit_web_context_get_spell_checking_languages(webContext); g_assert(!currentLanguage); // Check disabling and re-enabling spell checking. webkit_web_context_set_spell_checking_enabled(webContext, FALSE); g_assert(!webkit_web_context_get_spell_checking_enabled(webContext)); webkit_web_context_set_spell_checking_enabled(webContext, TRUE); g_assert(webkit_web_context_get_spell_checking_enabled(webContext)); }
/* Destroy items that falls out of the canvas */ static gboolean wordsgame_delete_items(gpointer user_data) { LettersItem *item; #if GLIB_CHECK_VERSION(2, 31, 0) g_mutex_lock (&items_lock); #else g_static_mutex_lock (&items_lock); #endif /* items2del may be NULL, as we can get called after wordsgame_destroy_all_items() has been called (since we get called as a timeout handler). */ if (items2del!=NULL){ while (items2del->len>0) { item = g_ptr_array_index(items2del,0); g_ptr_array_remove_index_fast(items2del,0); wordsgame_destroy_item(item); } } #if GLIB_CHECK_VERSION(2, 31, 0) g_mutex_unlock (&items_lock); #else g_static_mutex_unlock (&items_lock); #endif return (FALSE); }
static void gupnp_simple_igd_remove_port_real (GUPnPSimpleIgd *self, const gchar *protocol, guint external_port) { struct Mapping *mapping = NULL; guint i; g_return_if_fail (protocol); for (i = 0; i < self->priv->mappings->len; i++) { struct Mapping *tmpmapping = g_ptr_array_index (self->priv->mappings, i); if (tmpmapping->requested_external_port == external_port && !strcmp (tmpmapping->protocol, protocol)) { mapping = tmpmapping; break; } } if (!mapping) return; g_ptr_array_remove_index_fast (self->priv->mappings, i); free_mapping (self, mapping); }
static void free_mapping (GUPnPSimpleIgd *self, struct Mapping *mapping) { guint i, j; for (i=0; i < self->priv->service_proxies->len; i++) { struct Proxy *prox = g_ptr_array_index (self->priv->service_proxies, i); for (j=0; j < prox->proxymappings->len; j++) { struct ProxyMapping *pm = g_ptr_array_index (prox->proxymappings, j); if (pm->mapping == mapping) { free_proxymapping (pm, self); g_ptr_array_remove_index_fast (prox->proxymappings, j); j--; } } } g_free (mapping->protocol); g_free (mapping->local_ip); g_free (mapping->description); g_slice_free (struct Mapping, mapping); }
void ide_ctags_completion_provider_add_index (IdeCtagsCompletionProvider *self, IdeCtagsIndex *index) { GFile *file; gsize i; IDE_ENTRY; g_return_if_fail (IDE_IS_CTAGS_COMPLETION_PROVIDER (self)); g_return_if_fail (!index || IDE_IS_CTAGS_INDEX (index)); g_return_if_fail (self->indexes != NULL); file = ide_ctags_index_get_file (index); for (i = 0; i < self->indexes->len; i++) { IdeCtagsIndex *item = g_ptr_array_index (self->indexes, i); GFile *item_file = ide_ctags_index_get_file (item); if (g_file_equal (item_file, file)) { g_ptr_array_remove_index_fast (self->indexes, i); g_ptr_array_add (self->indexes, g_object_ref (index)); IDE_EXIT; } } g_ptr_array_add (self->indexes, g_object_ref (index)); IDE_EXIT; }
/* * Called when a note off is seen. Finds the corresponding note * on and constructs a note element. * * Arguments: * msp - Midi file state * note - Note number * vel - Note velocity */ static void finish_note(struct midistate *msp, int note, int vel) { int i; GPtrArray *notes; struct noteElement *n; int len; notes = msp->notes; n = NULL; for (i = notes->len-1; i >= 0; i--) { n = g_ptr_array_index(notes, i); if (n->note == note && MD_ELEMENT(n)->device_channel == msp->device) { len = msp->current_time - MD_ELEMENT(n)->element_time; n->offvel = vel; n->length = len; if (n->length < 0) { printf("Len neg: msp->time%d, s->time%d, note=%d, s.vel%d\n", msp->current_time, MD_ELEMENT(n)->element_time, note, n->vel); n->length = 0; } g_ptr_array_remove_index_fast(notes, i); break; } } }
/** * g_network_monitor_base_remove_network: * @monitor: the #GNetworkMonitorBase * @network: a #GInetAddressMask * * Removes @network from @monitor's list of available networks. * * Since: 2.32 */ void g_network_monitor_base_remove_network (GNetworkMonitorBase *monitor, GInetAddressMask *network) { int i; for (i = 0; i < monitor->priv->networks->len; i++) { if (g_inet_address_mask_equal (monitor->priv->networks->pdata[i], network)) { g_ptr_array_remove_index_fast (monitor->priv->networks, i); if (g_inet_address_mask_get_length (network) == 0) { switch (g_inet_address_mask_get_family (network)) { case G_SOCKET_FAMILY_IPV4: monitor->priv->have_ipv4_default_route = FALSE; break; case G_SOCKET_FAMILY_IPV6: monitor->priv->have_ipv6_default_route = FALSE; break; default: break; } } queue_network_changed (monitor); return; } } }
static void delete_property (GsmXSMPClient *client, const char *name) { int index; SmProp *prop; prop = find_property (client, name, &index); if (!prop) { return; } #if 0 /* This is wrong anyway; we can't unconditionally run the current * discard command; if this client corresponds to a GsmAppResumed, * and the current discard command is identical to the app's * discard_command, then we don't run the discard command now, * because that would delete a saved state we may want to resume * again later. */ if (!strcmp (name, SmDiscardCommand)) { gsm_client_run_discard (GSM_CLIENT (client)); } #endif g_ptr_array_remove_index_fast (client->priv->props, index); SmFreeProperty (prop); }
static void bb_liveness (MonoSimpleBasicBlock *bb) { GPtrArray* mark_stack = g_ptr_array_new (); GSList *tmp; /*All function entry points (prologue, EH handler/filter) are already marked*/ while (bb) { if (!bb->dead) g_ptr_array_add (mark_stack, bb); bb = bb->next; } while (mark_stack->len > 0) { MonoSimpleBasicBlock *block = g_ptr_array_remove_index_fast (mark_stack, mark_stack->len - 1); block->dead = FALSE; for (tmp = block->out_bb; tmp; tmp = tmp->next) { MonoSimpleBasicBlock *to = tmp->data; if (to->dead) g_ptr_array_add (mark_stack, to); } } g_ptr_array_free (mark_stack, TRUE); }
LogMessage * synthetic_message_generate_with_context(SyntheticMessage *self, CorrellationContext *context, GString *buffer) { LogMessage *genmsg; genmsg = _generate_default_message_from_context(self->inherit_mode, context); switch (context->key.scope) { case RCS_PROCESS: log_msg_set_value(genmsg, LM_V_PID, context->key.pid, -1); case RCS_PROGRAM: log_msg_set_value(genmsg, LM_V_PROGRAM, context->key.program, -1); case RCS_HOST: log_msg_set_value(genmsg, LM_V_HOST, context->key.host, -1); case RCS_GLOBAL: break; default: g_assert_not_reached(); break; } g_ptr_array_add(context->messages, genmsg); synthetic_message_apply(self, context, genmsg, buffer); g_ptr_array_remove_index_fast(context->messages, context->messages->len - 1); return genmsg; }
static void _gcr_display_view_dispose (GObject *obj) { GcrDisplayView *self = GCR_DISPLAY_VIEW (obj); GcrRenderer *renderer; GcrDisplayItem *item; while (self->pv->renderers->len) { renderer = g_ptr_array_index (self->pv->renderers, 0); item = g_hash_table_lookup (self->pv->items, renderer); g_return_if_fail (item); g_signal_handler_disconnect (renderer, item->data_changed_id); if (!g_hash_table_remove (self->pv->items, renderer)) g_return_if_reached (); g_ptr_array_remove_index_fast (self->pv->renderers, 0); } if (self->pv->buffer) g_object_unref (self->pv->buffer); self->pv->buffer = NULL; g_assert (g_hash_table_size (self->pv->items) == 0); G_OBJECT_CLASS (_gcr_display_view_parent_class)->dispose (obj); }
/** Callback invoked when a libusb FD should be removed from the poll set. */ static LIBUSB_CALL void usb_pollfd_removed(libusb_os_handle fd, void *user_data) { struct usb_source *usource; GPollFD *pollfd; unsigned int i; usource = user_data; if (G_UNLIKELY(g_source_is_destroyed(&usource->base))) return; /* It's likely that the removed poll FD is at the end. */ for (i = usource->pollfds->len; G_LIKELY(i > 0); i--) { pollfd = g_ptr_array_index(usource->pollfds, i - 1); if ((libusb_os_handle)pollfd->fd == fd) { g_source_remove_poll(&usource->base, pollfd); g_ptr_array_remove_index_fast(usource->pollfds, i - 1); return; } } sr_err("FD to be removed (%" G_GINTPTR_FORMAT ") not found in event source poll set.", (gintptr)fd); }
static void content_removed (TpCallChannel *proxy, TpCallContent *content_proxy, TpCallStateReason *reason, TfCallChannel *self) { guint i; if (!self->contents) return; for (i = 0; i < self->contents->len; i++) { if (tf_call_content_get_proxy (g_ptr_array_index (self->contents, i)) == content_proxy) { TfCallContent *content = g_ptr_array_index (self->contents, i); g_object_ref (content); g_ptr_array_remove_index_fast (self->contents, i); g_signal_emit (self, signals[SIGNAL_CONTENT_REMOVED], 0, content); g_object_unref (content); return; } } }
static void shutdown_fd_locked (FsMsnConnection *self, FsMsnPollFD *pollfd, gboolean equal) { gint i; guint closed = 0; for (i = 0; i < self->pollfds->len; i++) { FsMsnPollFD *p = g_ptr_array_index(self->pollfds, i); if ((equal && p == pollfd) || (!equal && p != pollfd)) { GST_DEBUG ("Shutting down p %p (fd %d)", p, p->pollfd.fd); if (!gst_poll_fd_has_closed (self->poll, &p->pollfd)) close (p->pollfd.fd); if (!gst_poll_remove_fd (self->poll, &p->pollfd)) GST_WARNING ("Could not remove pollfd %p", p); g_ptr_array_remove_index_fast (self->pollfds, i); g_slice_free (FsMsnPollFD, p); closed++; i--; } } if (closed) gst_poll_restart (self->poll); else GST_WARNING ("Could find pollfd to remove"); }
static void cell_destroyed (GucharmapChartableCellAccessible *cell) { GucharmapChartableAccessiblePrivate *priv; AtkObject *parent; GPtrArray *cells; guint n_cells, n; GucharmapChartableAccessible *accessible; parent = atk_object_get_parent (ATK_OBJECT (cell)); accessible = GUCHARMAP_CHARTABLE_ACCESSIBLE (parent); priv = GET_PRIVATE (accessible); cells = priv->cells; n_cells = cells->len; for (n = 0; n < n_cells; ++n) { GucharmapChartableCellAccessible *another_cell = g_ptr_array_index (cells, n); if (another_cell == cell) { g_ptr_array_remove_index_fast (priv->cells, n); return; } } g_warning ("Cell destroyed but was not in the cells cache?\n"); }
gboolean aclist_free(ACList *in_aclist) { if (in_aclist == NULL) { return FALSE; } gboolean ret_val = TRUE; while (in_aclist->entries->len > 0) { ACEntry *entry = (ACEntry*)g_ptr_array_remove_index_fast(in_aclist->entries, 0); if (!acentry_free(entry)) { ret_val = FALSE; } } g_ptr_array_free(in_aclist->entries, TRUE); in_aclist->entries = NULL; mark_dirty(in_aclist); rra_free_type(ACList, in_aclist); allocation_count--; return ret_val; }
void conscience_srv_destroy(struct conscience_srv_s *service) { if (!service) return; /*free the tags */ if (service->tags) { while (service->tags->len > 0) { struct service_tag_s *tag = g_ptr_array_index(service->tags,0); service_tag_destroy(tag); g_ptr_array_remove_index_fast(service->tags, 0); } g_ptr_array_free(service->tags, TRUE); } if (service->app_data_type==SAD_PTR) { if (service->app_data.pointer.value && service->app_data.pointer.cleaner) service->app_data.pointer.cleaner(service->app_data.pointer.value); } /*remove from the ring */ service_ring_remove(service); /*cleans the structure */ memset(service, 0x00, sizeof(struct conscience_srv_s)); g_free(service); }
void CPicoModel::RemoveParent( CPicoParent *parent ){ unsigned int i; for ( i = 0; i < m_parents->len; i++ ) { if ( parent == (CPicoParent*)m_parents->pdata[i] ) { g_ptr_array_remove_index_fast( m_parents, i ); } } }
/** Write an autosave. */ void load_save_autosave(void) { #ifdef DEBUG printf("load_save_autosave\n"); #endif gchar buf[SMALL], name[SMALL], directory[SMALL], prefix[SMALL]; const gchar *home = g_get_home_dir(); FILE *fil = NULL; gchar *pwd = g_get_current_dir(); if(!opt_int("int_opt_autosave")) return; counters[COUNT_AUTOSAVE] = (counters[COUNT_AUTOSAVE] + 1) % opt_int("int_opt_autosave_interval"); if(counters[COUNT_AUTOSAVE] != 0) return; load_save_write_autosave_name(name); if(os_is_unix) sprintf(directory, "%s%s%s%ssaves", home, G_DIR_SEPARATOR_S, HOMEDIRNAME, G_DIR_SEPARATOR_S); else { sprintf(directory, "%s%ssaves", pwd, G_DIR_SEPARATOR_S); g_free(pwd); } sprintf(name, "%s.zip", name); sprintf(buf, "%s%s%s", directory, G_DIR_SEPARATOR_S, name); if(!file_my_fopen(buf, "w", &fil, FALSE)) return; fclose(fil); sprintf(prefix, "autosave_%02d_", counters[COUNT_AUTOSAVE_FILE]); load_save_save_game(buf); chdir(directory); GPtrArray *files = file_dir_get_contents(directory, prefix, ".zip"); // Remove the zipfile from the list gint i; for(i=0; i<files->len; i++) { if (g_strcmp0((gchar*)g_ptr_array_index(files, i),name)==0) { g_ptr_array_remove_index_fast(files, i); } } file_remove_files(files); chdir(pwd); g_free(pwd); free_gchar_array(&files); counters[COUNT_AUTOSAVE_FILE] = (counters[COUNT_AUTOSAVE_FILE] + 1) % opt_int("int_opt_autosave_files"); }
/** * camel_imap_message_cache_new: * @path: directory to use for storage * @summary: CamelFolderSummary for the folder we are caching * @ex: a CamelException * * Return value: a new CamelImapMessageCache object using @path for * storage. If cache files already exist in @path, then any that do not * correspond to messages in @summary will be deleted. **/ CamelImapMessageCache * camel_imap_message_cache_new (const char *path, CamelFolderSummary *summary, CamelException *ex) { CamelImapMessageCache *cache; GDir *dir; const char *dname; char *uid, *p; GPtrArray *deletes; CamelMessageInfo *info; GError *error = NULL; dir = g_dir_open (path, 0, &error); if (!dir) { camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Could not open cache directory: %s"), error->message); g_error_free (error); return NULL; } cache = (CamelImapMessageCache *)camel_object_new (CAMEL_IMAP_MESSAGE_CACHE_TYPE); cache->path = g_strdup (path); cache->parts = g_hash_table_new (g_str_hash, g_str_equal); cache->cached = g_hash_table_new (NULL, NULL); deletes = g_ptr_array_new (); while ((dname = g_dir_read_name (dir))) { if (!isdigit (dname[0])) continue; p = strchr (dname, '.'); if (p) uid = g_strndup (dname, p - dname); else uid = g_strdup (dname); info = camel_folder_summary_uid (summary, uid); if (info) { camel_message_info_free(info); cache_put (cache, uid, dname, NULL); } else g_ptr_array_add (deletes, g_strdup_printf ("%s/%s", cache->path, dname)); g_free (uid); } g_dir_close (dir); while (deletes->len) { g_unlink (deletes->pdata[0]); g_free (deletes->pdata[0]); g_ptr_array_remove_index_fast (deletes, 0); } g_ptr_array_free (deletes, TRUE); return cache; }
void WebSoupRequestManager::registerURIScheme(const String& scheme) { if (m_schemes->len) g_ptr_array_remove_index_fast(m_schemes.get(), m_schemes->len - 1); g_ptr_array_add(m_schemes.get(), g_strdup(scheme.utf8().data())); g_ptr_array_add(m_schemes.get(), 0); SoupSession* session = WebCore::SoupNetworkSession::defaultSession().soupSession(); SoupRequestClass* genericRequestClass = static_cast<SoupRequestClass*>(g_type_class_ref(WEBKIT_TYPE_SOUP_REQUEST_GENERIC)); genericRequestClass->schemes = const_cast<const char**>(reinterpret_cast<char**>(m_schemes->pdata)); soup_session_add_feature_by_type(session, WEBKIT_TYPE_SOUP_REQUEST_GENERIC); }
static inline void _frame_remove_link(BotCTransFrame *frame, BotCTransLink *link) { assert(frame == link->frame_from || frame == link->frame_to); for(int i=0, n=bot_g_ptr_array_size(frame->links); i<n; i++) { if(link == g_ptr_array_index(frame->links, i)) { g_ptr_array_remove_index_fast(frame->links, i); return; } } assert(FALSE); }
static void merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs) { GPtrArray *traces = ctf_fs->traces; guint range_start_idx = 0; unsigned int num_traces = 0; guint i; /* Sort the traces by uuid, then collapse traces with the same uuid in a single one. */ g_ptr_array_sort(traces, sort_traces_by_uuid); /* Find ranges of consecutive traces that share the same UUID. */ while (range_start_idx < traces->len) { guint range_len; struct ctf_fs_trace *range_start_trace = g_ptr_array_index(traces, range_start_idx); /* Exclusive end of range. */ guint range_end_exc_idx = range_start_idx + 1; while (range_end_exc_idx < traces->len) { struct ctf_fs_trace *this_trace = g_ptr_array_index(traces, range_end_exc_idx); if (!range_start_trace->metadata->tc->is_uuid_set || (bt_uuid_compare(range_start_trace->metadata->tc->uuid, this_trace->metadata->tc->uuid) != 0)) { break; } range_end_exc_idx++; } /* If we have two or more traces with matching UUIDs, merge them. */ range_len = range_end_exc_idx - range_start_idx; if (range_len > 1) { struct ctf_fs_trace **range_start = (struct ctf_fs_trace **) &traces->pdata[range_start_idx]; merge_ctf_fs_traces(range_start, range_len); } num_traces++; range_start_idx = range_end_exc_idx; } /* Clear any NULL slot (traces that got merged in another one) in the array. */ for (i = 0; i < traces->len;) { if (g_ptr_array_index(traces, i) == NULL) { g_ptr_array_remove_index_fast(traces, i); } else { i++; } } BT_ASSERT(num_traces == traces->len); }
gboolean gupnp_simple_igd_delete_all_mappings (GUPnPSimpleIgd *self) { self->priv->no_new_mappings = TRUE; while (self->priv->mappings->len) { free_mapping (self, g_ptr_array_index (self->priv->mappings, 0)); g_ptr_array_remove_index_fast (self->priv->mappings, 0); } return (self->priv->deleting_count == 0); }
static void clear_items (EBookBackendSummary *summary) { gint i; gint num = summary->priv->items->len; for (i = 0; i < num; i++) { EBookBackendSummaryItem *item = g_ptr_array_remove_index_fast (summary->priv->items, 0); if (item) { g_hash_table_remove (summary->priv->id_to_item, item->id); free_summary_item (item); } } }
static void gst_device_monitor_remove (GstDeviceMonitor * self, guint i) { GstDeviceProvider *provider = g_ptr_array_index (self->priv->providers, i); GstBus *bus; g_ptr_array_remove_index_fast (self->priv->providers, i); bus = gst_device_provider_get_bus (provider); g_signal_handlers_disconnect_by_func (bus, bus_sync_message, self); gst_object_unref (bus); gst_object_unref (provider); }