void g_sequence_remove_sorted ( GSequence * seq, gpointer data, GCompareDataFunc cmp_func, gpointer cmp_data ) { gpointer found; GSequenceIter * sj, * si = g_sequence_lookup( seq, data, cmp_func, cmp_data ); if ( si == NULL ) return; sj = si; while ( !g_sequence_iter_is_end( sj ) ) { found = g_sequence_get( sj ); if ( found == data ) return g_sequence_remove( sj ); else if ( cmp_func( found, data, cmp_data ) != 0 ) break; sj = g_sequence_iter_next( sj ); } sj = si; while ( !g_sequence_iter_is_begin( sj ) ) { sj = g_sequence_iter_prev( sj ); found = g_sequence_get( sj ); if ( found == data ) return g_sequence_remove( sj ); else if ( cmp_func( found, data, cmp_data ) != 0 ) break; } }
void swfdec_text_buffer_delete_text (SwfdecTextBuffer *buffer, gsize pos, gsize length) { GSequenceIter *iter, *prev; SwfdecTextBufferFormat *format; gsize end; g_return_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer)); g_return_if_fail (pos + length <= buffer->text->len); g_return_if_fail (length > 0); g_string_erase (buffer->text, pos, length); end = pos + length; prev = NULL; for (iter = swfdec_text_buffer_get_iter_for_pos (buffer, pos); !g_sequence_iter_is_end (iter); iter = g_sequence_iter_next (iter)) { format = g_sequence_get (iter); if (format->start < pos) continue; if (format->start > end) { format->start -= length; continue; } if (prev) g_sequence_remove (prev); format->start = pos; prev = iter; } if (prev && pos == buffer->text->len) g_sequence_remove (prev); CHECK_ATTRIBUTES (buffer); /* adapt cursor */ if (buffer->cursor_start > end) buffer->cursor_start -= length; else if (buffer->cursor_start > pos) buffer->cursor_start = pos; if (buffer->cursor_end > end) buffer->cursor_end -= length; else if (buffer->cursor_end > pos) buffer->cursor_end = pos; g_signal_emit (buffer, signals[TEXT_CHANGED], 0); g_signal_emit (buffer, signals[CURSOR_CHANGED], 0, (gulong) MIN (buffer->cursor_start, buffer->cursor_end), (gulong) MAX (buffer->cursor_start, buffer->cursor_end)); }
static void g_file_monitor_source_dispose (GFileMonitorSource *fms) { g_mutex_lock (&fms->lock); if (fms->instance) { GHashTableIter iter; gpointer seqiter; QueuedEvent *event; g_hash_table_iter_init (&iter, fms->pending_changes_table); while (g_hash_table_iter_next (&iter, NULL, &seqiter)) { g_hash_table_iter_remove (&iter); g_sequence_remove (seqiter); } while ((event = g_queue_pop_head (&fms->event_queue))) queued_event_free (event); g_assert (g_sequence_is_empty (fms->pending_changes)); g_assert (g_hash_table_size (fms->pending_changes_table) == 0); g_assert (fms->event_queue.length == 0); fms->instance = NULL; g_file_monitor_source_update_ready_time (fms); } g_mutex_unlock (&fms->lock); g_source_destroy ((GSource *) fms); }
static void remove_entry(IsStore *self, IsStoreEntry *entry) { IsStorePrivate *priv; GtkTreeIter iter; GtkTreePath *path; GSequenceIter *parent_iter; priv = self->priv; parent_iter = entry->parent; iter.stamp = priv->stamp; iter.user_data = entry->iter; path = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &iter); g_sequence_remove(entry->iter); gtk_tree_model_row_deleted(GTK_TREE_MODEL(self), path); gtk_tree_path_free(path); /* remove parent if it has no children now */ if (parent_iter) { IsStoreEntry *parent = g_sequence_get(parent_iter); if (g_sequence_get_length(parent->entries) == 0) { remove_entry(self, parent); } } }
/** * gst_rtsp_mount_points_remove_factory: * @mounts: a #GstRTSPMountPoints * @path: a mount point * * Remove the #GstRTSPMediaFactory associated with @path in @mounts. */ void gst_rtsp_mount_points_remove_factory (GstRTSPMountPoints * mounts, const gchar * path) { GstRTSPMountPointsPrivate *priv; DataItem item; GSequenceIter *iter; g_return_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts)); g_return_if_fail (path != NULL); priv = mounts->priv; item.path = (gchar *) path; GST_INFO ("removing media factory for path %s", path); g_mutex_lock (&priv->lock); if (priv->dirty) { g_sequence_sort (priv->mounts, data_item_compare, mounts); priv->dirty = FALSE; } iter = g_sequence_lookup (priv->mounts, &item, data_item_compare, mounts); if (iter) { g_sequence_remove (iter); priv->dirty = TRUE; } g_mutex_unlock (&priv->lock); }
static void photos_base_manager_default_remove_object_by_id (PhotosBaseManager *self, const gchar *id) { PhotosBaseManagerPrivate *priv; GObject *object; PhotosBaseManagerObjectData *object_data; guint position; priv = photos_base_manager_get_instance_private (self); object_data = g_hash_table_lookup (priv->objects, id); if (object_data == NULL) return; position = g_sequence_iter_get_position (object_data->iter); g_sequence_remove (object_data->iter); object = g_object_ref (object_data->object); g_hash_table_remove (priv->objects, id); photos_base_manager_objects_changed (self, position, 1, 0); g_signal_emit (self, signals[OBJECT_REMOVED], 0, object); g_object_unref (object); }
static void fm_ogl_model_remove (FMOGLModel *model, GSequenceIter *iter) { FileEntry *file_entry; file_entry = g_sequence_get (iter); g_sequence_remove (iter); }
static void service_remove(struct connman_service *service) { GHashTableIter iter; gpointer key, value; struct connman_session *session; struct session_info *info; DBG("service %p", service); g_hash_table_iter_init(&iter, session_hash); while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) { GSequenceIter *seq_iter; session = value; info = session->info; seq_iter = g_hash_table_lookup(session->service_hash, service); if (seq_iter == NULL) continue; g_sequence_remove(seq_iter); if (info->entry != NULL && info->entry->service == service) info->entry = NULL; session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE); } }
/** * ide_recent_projects_remove: * @self: An #IdeRecentProjects * @project_infos: (transfer none) (element-type IdeProjectInfo): A #GList of #IdeProjectInfo. * * Removes the provided projects from the recent projects file. */ void ide_recent_projects_remove (IdeRecentProjects *self, GList *project_infos) { g_autoptr(GBookmarkFile) projects_file = NULL; g_autoptr(GError) error = NULL; GList *liter; g_return_if_fail (IDE_IS_RECENT_PROJECTS (self)); projects_file = ide_recent_projects_get_bookmarks (self, &error); if (projects_file == NULL) { g_warning ("Failed to load bookmarks file: %s", error->message); return; } for (liter = project_infos; liter; liter = liter->next) { IdeProjectInfo *project_info = liter->data; g_autofree gchar *file_uri = NULL; GSequenceIter *iter; GFile *file; g_assert (IDE_IS_PROJECT_INFO (liter->data)); iter = g_sequence_lookup (self->projects, project_info, (GCompareDataFunc)ide_project_info_compare, NULL); if (iter == NULL) { g_warning ("Project \"%s\" was not found, cannot remove.", ide_project_info_get_name (project_info)); g_clear_error (&error); continue; } file = ide_project_info_get_file (project_info); file_uri = g_file_get_uri (file); if (!g_bookmark_file_remove_item (projects_file, file_uri, &error)) { g_warning ("Failed to remove recent project: %s", error->message); g_clear_error (&error); continue; } g_sequence_remove (iter); } if (!g_bookmark_file_to_file (projects_file, self->file_uri, &error)) { g_warning ("Failed to save recent projects file: %s", error->message); return; } }
static void ide_recent_projects_added (IdeRecentProjects *self, IdeProjectInfo *project_info) { g_autofree gchar *uri = NULL; GFile *file; g_assert (IDE_IS_RECENT_PROJECTS (self)); g_assert (IDE_IS_PROJECT_INFO (project_info)); file = ide_project_info_get_file (project_info); uri = g_file_get_uri (file); if (!g_hash_table_contains (self->recent_uris, uri)) { GSequenceIter *iter; gint position; iter = g_sequence_insert_sorted (self->projects, g_object_ref (project_info), (GCompareDataFunc)ide_project_info_compare, NULL); position = g_sequence_iter_get_position (iter); if (position > MAX_PROJECT_INFOS) g_sequence_remove (iter); else g_list_model_items_changed (G_LIST_MODEL (self), position, 0, 1); } }
/** * @brief Send message to each expired alarm. */ static void notify_alarms(void) { time_t now; bool fired = false; now = reference_time(); GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms); while (!g_sequence_iter_is_end(iter)) { _Alarm *alarm = (_Alarm *)g_sequence_get(iter); GSequenceIter *next = g_sequence_iter_next(iter); if (alarm && alarm->expiry <= now) { fire_alarm(alarm); g_sequence_remove(iter); fired = true; } iter = next; } if (fired) { alarm_write_db(); } }
void fm_folder_model_file_deleted(FmFolderModel* model, FmFileInfo* file) { GSequenceIter *seq_it; /* not required for hidden files */ gboolean update_view; #if 0 /* If there is no file info, that means the dir itself was deleted. */ if( G_UNLIKELY(!file) ) { /* Clear the whole list */ GSequenceIter *items_it = g_sequence_get_begin_iter(model->items); path = gtk_tree_path_new_from_indices(0, -1); while( !g_sequence_iter_is_end(items_it) ) { gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), path); file = (VFSFileInfo*)g_sequence_get(items_it); items_it = g_sequence_iter_next(it); vfs_file_info_unref(file); } for( l = model->items; l; l = model->items ) { gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), path); file = (VFSFileInfo*)l->data; model->items = g_list_delete_link(model->items, l); vfs_file_info_unref(file); } g_sequence_remove_range( g_sequence_get_begin_iter(model->items), g_sequence_get_end_iter(model->items) ); gtk_tree_path_free(path); return; } #endif if( !model->show_hidden && fm_file_info_is_hidden(file) ) /* if this is a hidden file */ { update_view = FALSE; seq_it = g_sequence_get_begin_iter(model->hidden); } else { update_view = TRUE; seq_it = g_sequence_get_begin_iter(model->items); } while( !g_sequence_iter_is_end(seq_it) ) { FmFolderItem* item = (FmFolderItem*)g_sequence_get(seq_it); if( item->inf == file ) break; seq_it = g_sequence_iter_next(seq_it); } if( update_view ) { GtkTreePath* path = gtk_tree_path_new_from_indices(g_sequence_iter_get_position(seq_it), -1); gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), path); gtk_tree_path_free(path); } model->iter_age++; g_sequence_remove(seq_it); }
void sorted_sequence_remove(SortedSequence * sequence, gpointer data) { GSequenceIter * iter = g_sequence_search(sequence -> seq, data, sequence -> cmp_func, NULL); GSequenceIter * prev = g_sequence_iter_prev(iter); gpointer element = g_sequence_get(prev); if(sequence -> cmp_func(data, element, NULL) == 0){ g_sequence_remove(prev); } }
static void g_file_monitor_source_remove_pending_change (GFileMonitorSource *fms, GSequenceIter *iter, const gchar *child) { /* must remove the hash entry first -- its key is owned by the data * which will be freed when removing the sequence iter */ g_hash_table_remove (fms->pending_changes_table, child); g_sequence_remove (iter); }
void free_segment(struct segment* s) { GSequenceIter *begin = g_sequence_get_begin_iter(s->chunks); GSequenceIter *end = g_sequence_get_end_iter(s->chunks); for(; begin != end; begin = g_sequence_get_begin_iter(s->chunks)){ free_chunk(g_sequence_get(begin)); g_sequence_remove(begin); } g_sequence_free(s->chunks); if (s->features) g_hash_table_destroy(s->features); free(s); }
static void decorator_blacklist_remove (TrackerDecorator *decorator, gint id) { TrackerDecoratorPrivate *priv = decorator->priv; GSequenceIter *iter; iter = g_sequence_lookup (priv->blacklist_items, GINT_TO_POINTER (id), sequence_compare_func, NULL); if (iter) g_sequence_remove (iter); }
// Called from the hub tab when something changes to the user list. void uit_userlist_userchange(ui_tab_t *tab, int change, hub_user_t *user) { tab_t *t = (tab_t *)tab; if(change == UIHUB_UC_JOIN) { user->iter = g_sequence_insert_sorted(t->list->list, user, sort_func, t); ui_listing_inserted(t->list); } else if(change == UIHUB_UC_QUIT) { g_return_if_fail(g_sequence_get(user->iter) == (gpointer)user); ui_listing_remove(t->list, user->iter); g_sequence_remove(user->iter); } else { g_sequence_sort_changed(user->iter, sort_func, t); ui_listing_sorted(t->list); } }
static void clutter_list_model_row_removed (ClutterModel *model, ClutterModelIter *iter) { ClutterListModelIter *iter_default; GValueArray *array; iter_default = CLUTTER_LIST_MODEL_ITER (iter); array = g_sequence_get (iter_default->seq_iter); g_value_array_free (array); g_sequence_remove (iter_default->seq_iter); iter_default->seq_iter = NULL; }
/* removes duplicates in the range [iter, end) */ static void swfdec_text_buffer_remove_duplicates (GSequenceIter *iter, GSequenceIter *end) { SwfdecTextBufferFormat *format, *next; g_assert (iter != end); format = g_sequence_get (iter); for (iter = g_sequence_iter_next (iter); iter != end; iter = g_sequence_iter_next (iter)) { next = g_sequence_get (iter); if (swfdec_text_attributes_diff (&format->attr, &next->attr) == 0) { GSequenceIter *prev = g_sequence_iter_prev (iter); g_sequence_remove (iter); iter = prev; } else { format = next; } } }
gboolean egg_sorted_hash_remove (EggSortedHash *hash, gpointer key, guint *position) { GSequenceIter *it; it = g_hash_table_lookup (hash->iters, key); if (it) { if (position) *position = g_sequence_iter_get_position (it); g_sequence_remove (it); g_hash_table_remove (hash->iters, key); return TRUE; } return FALSE; }
/** * ide_debugger_address_map_remove: * @self: a #IdeDebuggerAddressMap * @address: the address contained in the map * * Removes the entry found containing @address. * * Since: 3.32 */ gboolean ide_debugger_address_map_remove (IdeDebuggerAddressMap *self, IdeDebuggerAddress address) { IdeDebuggerAddressMapEntry entry = { NULL, 0, address, 0 }; GSequenceIter *iter; g_return_val_if_fail (self != NULL, FALSE); iter = g_sequence_lookup (self->seq, &entry, ide_debugger_address_map_entry_compare_in_range, NULL); if (iter == NULL || g_sequence_iter_is_end (iter)) return FALSE; g_sequence_remove (iter); return TRUE; }
void send_segment(struct segment* s) { /* * CHUNK_SEGMENT_START and _END are used for * reconstructing the segment in filter phase. */ struct chunk* ss = new_chunk(0); SET_CHUNK(ss, CHUNK_SEGMENT_START); sync_queue_push(dedup_queue, ss); GSequenceIter *end = g_sequence_get_end_iter(s->chunks); GSequenceIter *begin = g_sequence_get_begin_iter(s->chunks); while(begin != end) { struct chunk* c = g_sequence_get(begin); if (!CHECK_CHUNK(c, CHUNK_FILE_START) && !CHECK_CHUNK(c, CHUNK_FILE_END)) { if (CHECK_CHUNK(c, CHUNK_DUPLICATE)) { if (c->id == TEMPORARY_ID) { DEBUG("Dedup phase: %ldth chunk is identical to a unique chunk", chunk_num++); } else { DEBUG("Dedup phase: %ldth chunk is duplicate in container %lld", chunk_num++, c->id); } } else { DEBUG("Dedup phase: %ldth chunk is unique", chunk_num++); } } sync_queue_push(dedup_queue, c); g_sequence_remove(begin); begin = g_sequence_get_begin_iter(s->chunks); } struct chunk* se = new_chunk(0); SET_CHUNK(se, CHUNK_SEGMENT_END); sync_queue_push(dedup_queue, se); s->chunk_num = 0; }
static void bt_pattern_list_model_rem (BtPatternListModel * model, BtPattern * pattern) { GSequence *seq = model->priv->seq; GtkTreePath *path; GSequenceIter *iter; gint position; GST_INFO ("removing pattern from model"); // remove entry iter = g_sequence_lookup (seq, pattern, model_item_cmp, NULL); position = g_sequence_iter_get_position (iter); g_sequence_remove (iter); // signal to the view/app path = gtk_tree_path_new (); gtk_tree_path_append_index (path, position); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); GST_INFO ("removed pattern from model at pos %d ", position); }
/** * gst_timed_value_control_source_unset: * @self: the #GstTimedValueControlSource object * @timestamp: the time the control-change should be removed from * * Used to remove the value of given controller-handled property at a certain * time. * * Returns: FALSE if the value couldn't be unset (i.e. not found, TRUE otherwise. */ gboolean gst_timed_value_control_source_unset (GstTimedValueControlSource * self, GstClockTime timestamp) { GSequenceIter *iter; gboolean res = FALSE; GstControlPoint *cp = NULL; g_return_val_if_fail (GST_IS_TIMED_VALUE_CONTROL_SOURCE (self), FALSE); g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (timestamp), FALSE); g_mutex_lock (&self->lock); /* check if a control point for the timestamp exists */ if (G_LIKELY (self->values) && (iter = g_sequence_lookup (self->values, ×tamp, (GCompareDataFunc) gst_control_point_find, NULL))) { /* Iter contains the iter right after timestamp, i.e. * we need to get the previous one and check the timestamp */ cp = g_slice_dup (GstControlPoint, g_sequence_get (iter)); g_sequence_remove (iter); self->nvalues--; self->valid_cache = FALSE; res = TRUE; } g_mutex_unlock (&self->lock); if (cp) { g_signal_emit (self, gst_timed_value_control_source_signals[VALUE_REMOVED_SIGNAL], 0, cp); g_slice_free (GstControlPoint, cp); } return res; }
/** * ide_recent_projects_remove: * @self: An #IdeRecentProjects * @project_infos: (transfer none) (element-type IdeProjectInfo): A #GList of #IdeProjectInfo. * * Removes the provided projects from the recent projects file. */ void ide_recent_projects_remove (IdeRecentProjects *self, GList *project_infos) { g_autoptr(GBookmarkFile) projects_file = NULL; g_autoptr(GError) error = NULL; GList *liter; g_return_if_fail (IDE_IS_RECENT_PROJECTS (self)); projects_file = ide_recent_projects_get_bookmarks (self, &error); if (projects_file == NULL) { g_warning ("Failed to load bookmarks file: %s", error->message); return; } for (liter = project_infos; liter; liter = liter->next) { IdeProjectInfo *project_info = liter->data; g_autofree gchar *file_uri = NULL; GSequenceIter *iter; GFile *file; g_assert (IDE_IS_PROJECT_INFO (liter->data)); iter = g_sequence_lookup (self->projects, project_info, (GCompareDataFunc)ide_project_info_compare, NULL); if (iter == NULL) { g_warning ("Project \"%s\" was not found, cannot remove.", ide_project_info_get_name (project_info)); g_clear_error (&error); continue; } file = ide_project_info_get_file (project_info); file_uri = g_file_get_uri (file); if (!g_bookmark_file_remove_item (projects_file, file_uri, &error)) { g_autofree gchar *with_slash = g_strdup_printf ("%s/", file_uri); /* Sometimes we don't get a match because the directory is missing a * trailing slash. Annoying, I know. See the following for the * upstream bug filed in GLib. * * https://bugzilla.gnome.org/show_bug.cgi?id=765449 */ if (!g_bookmark_file_remove_item (projects_file, with_slash, NULL)) { g_warning ("Failed to remove recent project: %s", error->message); g_clear_error (&error); continue; } g_clear_error (&error); } g_sequence_remove (iter); } if (!g_bookmark_file_to_file (projects_file, self->file_uri, &error)) { g_warning ("Failed to save recent projects file: %s", error->message); return; } }
/* * Select the top segments that are most similar with features. * (top-k * prefetching_num) cannot be larger than the segment cache size. */ static void top_segment_select(GHashTable* features) { /* * Mapping segment IDs to similar segments that hold at least one of features. */ GHashTable *similar_segments = g_hash_table_new_full(g_int64_hash, g_int64_equal, NULL, free_segment); GHashTableIter iter; gpointer key, value; g_hash_table_iter_init(&iter, features); /* Iterate the features of the segment. */ while (g_hash_table_iter_next(&iter, &key, &value)) { /* Each feature is mapped to several segment IDs. */ segmentid *ids = kvstore_lookup((fingerprint*) key); if (ids) { index_overhead.lookup_requests++; int i; for (i = 0; i < destor.index_value_length; i++) { if (ids[i] == TEMPORARY_ID) break; struct segment* s = g_hash_table_lookup(similar_segments, &ids[i]); if (!s) { s = new_segment_full(); s->id = ids[i]; g_hash_table_insert(similar_segments, &s->id, s); } char* feature = malloc(destor.index_key_size); memcpy(feature, key, destor.index_key_size); assert(!g_hash_table_contains(s->features, feature)); g_hash_table_insert(s->features, feature, NULL); } }else{ index_overhead.lookup_requests_for_unique++; } } if (g_hash_table_size(similar_segments) != 0) { /* Sorting similar segments in order of their number of hit features. */ GSequence *seq = g_sequence_new(NULL); GHashTableIter iter; gpointer key, value; g_hash_table_iter_init(&iter, similar_segments); while (g_hash_table_iter_next(&iter, &key, &value)) { /* Insert similar segments into GSequence. */ struct segment* s = value; NOTICE("candidate segment %lld with %d shared features", s->id, g_hash_table_size(s->features)); g_sequence_insert_sorted(seq, s, g_segment_cmp_feature_num, NULL); } /* The number of selected similar segments */ int num = g_sequence_get_length(seq) > destor.index_segment_selection_method[1] ? destor.index_segment_selection_method[1] : g_sequence_get_length(seq), i; NOTICE("select Top-%d in %d segments", num, g_sequence_get_length(seq)); /* Prefetched top similar segments are pushed into the queue. */ for (i = 0; i < num; i++) { /* Get the top segment */ struct segment *top = g_sequence_get( g_sequence_get_begin_iter(seq)); NOTICE("read segment %lld", top->id); fingerprint_cache_prefetch(top->id); g_sequence_remove(g_sequence_get_begin_iter(seq)); g_sequence_foreach(seq, features_trim, top); g_sequence_sort(seq, g_segment_cmp_feature_num, NULL); } g_sequence_free(seq); } g_hash_table_destroy(similar_segments); }
void close_har() { sds fname = sdsdup(destor.working_directory); fname = sdscat(fname, "recipes/bv"); char s[20]; sprintf(s, "%d", jcr.id); fname = sdscat(fname, s); fname = sdscat(fname, ".sparse"); FILE* fp = fopen(fname, "w"); if (!fp) { fprintf(stderr, "Can not create sparse file"); perror("The reason is"); exit(1); } jcr.total_container_num = g_hash_table_size(container_utilization_monitor); GSequence *seq = g_sequence_new(NULL); int64_t total_size = 0; int64_t sparse_size = 0; /* collect sparse containers */ GHashTableIter iter; gpointer key, value; g_hash_table_iter_init(&iter, container_utilization_monitor); while (g_hash_table_iter_next(&iter, &key, &value)) { struct containerRecord* cr = (struct containerRecord*) value; total_size += cr->size; if((1.0*cr->size/(CONTAINER_SIZE - CONTAINER_META_SIZE)) < destor.rewrite_har_utilization_threshold){ /* It is sparse */ if (inherited_sparse_containers && g_hash_table_lookup(inherited_sparse_containers, &cr->cid)) /* It is an inherited sparse container */ jcr.inherited_sparse_num++; jcr.sparse_container_num++; sparse_size += cr->size; g_sequence_insert_sorted(seq, cr, g_record_cmp, NULL); } } /* * If the sparse size is too large, * we need to trim the sequence to control the rewrite ratio. * We use sparse_size/total_size to estimate the rewrite ratio of next backup. * However, the estimation is inaccurate (generally over-estimating), since: * 1. the sparse size is not an accurate indicator of utilization for next backup. * 2. self-references. */ while(sparse_size*1.0/total_size > destor.rewrite_har_rewrite_limit){ /* * The expected rewrite ratio exceeds the limit. * We trim the last several records in the sequence. * */ GSequenceIter* iter = g_sequence_iter_prev(g_sequence_get_end_iter(seq)); struct containerRecord* r = g_sequence_get(iter); NOTICE("Trim sparse container %lld", r->cid); sparse_size -= r->size; g_sequence_remove(iter); } GSequenceIter* sparse_iter = g_sequence_get_begin_iter(seq); while(sparse_iter != g_sequence_get_end_iter(seq)){ struct containerRecord* r = g_sequence_get(sparse_iter); fprintf(fp, "%lld %d\n", r->cid, r->size); sparse_iter = g_sequence_iter_next(sparse_iter); } fclose(fp); NOTICE("Record %d sparse containers, and %d of them are inherited", g_sequence_get_length(seq), jcr.inherited_sparse_num); g_sequence_free(seq); sdsfree(fname); }
Container *container_cache_insert_container(ContainerCache *cc, ContainerId cid) { /* read container */ Container *container = 0; TIMER_DECLARE(b, e); TIMER_BEGIN(b); if (cc->enable_data) { if (simulation_level >= SIMULATION_RECOVERY) { container = read_container_meta_only(cid); } else { container = read_container(cid); } } else { container = read_container_meta_only(cid); } TIMER_END(read_container_time, b, e); /* If this container is newly appended, * maybe we can read nothing. */ if (container == NULL) { return NULL; } /* insert */ Container *evictor = lru_cache_insert(cc->lru_cache, container); /* evict */ if (evictor) { int32_t chunknum = container_get_chunk_num(evictor); Fingerprint *fingers = container_get_all_fingers(evictor); int i = 0; /* evict all fingers of evictor from map */ for (; i < chunknum; ++i) { GSequence* container_list = g_hash_table_lookup(cc->map, &fingers[i]); /* remove the specified container from list */ GSequenceIter *iter = g_sequence_lookup(container_list, evictor, container_cmp_des, NULL); if (iter) g_sequence_remove(iter); else dprint("Error! The sequence does not contain the container."); if (g_sequence_get_length(container_list) == 0) { g_hash_table_remove(cc->map, &fingers[i]); } } free(fingers); if (fragment_stream) fprintf(fragment_stream, "%.4f\n", 1.0 * evictor->used_size / CONTAINER_SIZE); container_free_full(evictor); } /* insert */ int32_t num = container_get_chunk_num(container); Fingerprint *nfingers = container_get_all_fingers(container); int i = 0; for (; i < num; ++i) { GSequence* container_list = g_hash_table_lookup(cc->map, &nfingers[i]); if (container_list == 0) { container_list = g_sequence_new(NULL); Fingerprint *finger = (Fingerprint *) malloc(sizeof(Fingerprint)); memcpy(finger, &nfingers[i], sizeof(Fingerprint)); g_hash_table_insert(cc->map, finger, container_list); } g_sequence_insert_sorted(container_list, container, container_cmp_des, NULL); } free(nfingers); return container; }
/** * @brief Remove an alarm by id. * * {"alarmId":1} * * Response: * * {"returnValue":true} * * @param sh * @param message * @param ctx * * @retval */ static bool alarmRemove(LSHandle *sh, LSMessage *message, void *ctx) { LSError lserror; LSErrorInit(&lserror); bool found = false; bool retVal; const char *payload = LSMessageGetPayload(message); struct json_object *object = json_tokener_parse(payload); if (is_error(object)) { goto malformed_json; } SLEEPDLOG_DEBUG("alarmRemove() : %s", LSMessageGetPayload(message)); int alarmId = json_object_get_int(json_object_object_get(object, "alarmId")); GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms); while (!g_sequence_iter_is_end(iter)) { _Alarm *alarm = (_Alarm *)g_sequence_get(iter); GSequenceIter *next = g_sequence_iter_next(iter); if (alarm && alarm->id == alarmId) { char *timeout_key = g_strdup_printf("%s-%d", alarm->key, alarm->id); _timeout_clear("com.palm.sleep", timeout_key, false /*public_bus*/); g_free(timeout_key); g_sequence_remove(iter); found = true; } iter = next; } const char *response; if (found) { alarm_write_db(); response = "{\"returnValue\":true}"; } else { response = "{\"returnValue\":false}"; } retVal = LSMessageReply(sh, message, response, &lserror); if (!retVal) { LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); } goto cleanup; malformed_json: LSMessageReplyErrorBadJSON(sh, message); goto cleanup; cleanup: if (!is_error(object)) { json_object_put(object); } return true; }
gboolean fm_list_model_add_file (FMListModel *model, CajaFile *file, CajaDirectory *directory) { GtkTreeIter iter; GtkTreePath *path; FileEntry *file_entry; GSequenceIter *ptr, *parent_ptr; GSequence *files; gboolean replace_dummy; GHashTable *parent_hash; parent_ptr = g_hash_table_lookup (model->details->directory_reverse_map, directory); if (parent_ptr) { file_entry = g_sequence_get (parent_ptr); ptr = g_hash_table_lookup (file_entry->reverse_map, file); } else { file_entry = NULL; ptr = g_hash_table_lookup (model->details->top_reverse_map, file); } if (ptr != NULL) { g_warning ("file already in tree (parent_ptr: %p)!!!\n", parent_ptr); return FALSE; } file_entry = g_new0 (FileEntry, 1); file_entry->file = caja_file_ref (file); file_entry->parent = NULL; file_entry->subdirectory = NULL; file_entry->files = NULL; files = model->details->files; parent_hash = model->details->top_reverse_map; replace_dummy = FALSE; if (parent_ptr != NULL) { file_entry->parent = g_sequence_get (parent_ptr); /* At this point we set loaded. Either we saw * "done" and ignored it waiting for this, or we do this * earlier, but then we replace the dummy row anyway, * so it doesn't matter */ file_entry->parent->loaded = 1; parent_hash = file_entry->parent->reverse_map; files = file_entry->parent->files; if (g_sequence_get_length (files) == 1) { GSequenceIter *dummy_ptr = g_sequence_get_iter_at_pos (files, 0); FileEntry *dummy_entry = g_sequence_get (dummy_ptr); if (dummy_entry->file == NULL) { /* replace the dummy loading entry */ model->details->stamp++; g_sequence_remove (dummy_ptr); replace_dummy = TRUE; } } } file_entry->ptr = g_sequence_insert_sorted (files, file_entry, fm_list_model_file_entry_compare_func, model); g_hash_table_insert (parent_hash, file, file_entry->ptr); iter.stamp = model->details->stamp; iter.user_data = file_entry->ptr; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); if (replace_dummy) { gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); } else { gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); } if (caja_file_is_directory (file)) { file_entry->files = g_sequence_new ((GDestroyNotify)file_entry_free); add_dummy_row (model, file_entry); gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (model), path, &iter); } gtk_tree_path_free (path); return TRUE; }