/* 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);
}
