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;
}
