RmUserList *rm_userlist_new(void) {
struct passwd *node = NULL;
struct group *grp = NULL;
RmUserList *self = g_malloc0(sizeof(RmUserList));
self->users = g_sequence_new(NULL);
self->groups = g_sequence_new(NULL);
g_mutex_init(&self->mutex);
setpwent();
while((node = getpwent()) != NULL) {
g_sequence_insert_sorted(
self->users, GUINT_TO_POINTER(node->pw_uid), rm_userlist_cmp_ids, NULL
);
g_sequence_insert_sorted(
self->groups, GUINT_TO_POINTER(node->pw_gid), rm_userlist_cmp_ids, NULL
);
}
endpwent();
/* add all groups, not just those that are user primary gid's */
while((grp = getgrent()) != NULL) {
g_sequence_insert_sorted(
self->groups, GUINT_TO_POINTER(grp->gr_gid), rm_userlist_cmp_ids, NULL
);
}
endgrent();
return self;
}
//Function that takes a hash table entry and adds it to seq in a sorted order
void hash_func(gchar * key, Count * value, gpointer user_data){
Pair * pair = (Pair *)g_malloc(sizeof(Pair));
pair->key = key;
pair->val = value;
g_sequence_insert_sorted(seq,pair,(GCompareDataFunc)cmp_func,NULL);
}
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);
g_list_model_items_changed (G_LIST_MODEL (self), position, 0, 1);
}
}
static void service_add(struct connman_service *service,
const char *name)
{
GHashTableIter iter;
GSequenceIter *iter_service_list;
gpointer key, value;
struct connman_session *session;
struct service_entry *entry;
DBG("service %p", service);
g_hash_table_iter_init(&iter, session_hash);
while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
session = value;
if (service_match(session, service) == FALSE)
continue;
entry = create_service_entry(service, name,
CONNMAN_SERVICE_STATE_IDLE);
if (entry == NULL)
continue;
iter_service_list =
g_sequence_insert_sorted(session->service_list,
entry, sort_services,
session);
g_hash_table_replace(session->service_hash, service,
iter_service_list);
session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
}
}
ui_tab_t *uit_userlist_create(hub_t *hub) {
tab_t *t = g_new0(tab_t, 1);
t->tab.name = g_strdup_printf("@%s", hub->tab->name+1);
t->tab.type = uit_userlist;
t->tab.hub = hub;
t->opfirst = TRUE;
t->hide_conn = TRUE;
t->hide_mail = TRUE;
t->hide_ip = TRUE;
GSequence *users = g_sequence_new(NULL);
// populate the list
// g_sequence_sort() uses insertion sort? in that case it is faster to insert
// all items using g_sequence_insert_sorted() rather than inserting them in
// no particular order and then sorting them in one go. (which is faster for
// linked lists, since it uses a faster sorting algorithm)
GHashTableIter iter;
g_hash_table_iter_init(&iter, hub->users);
hub_user_t *u;
while(g_hash_table_iter_next(&iter, NULL, (gpointer *)&u))
u->iter = g_sequence_insert_sorted(users, u, sort_func, t);
t->list = ui_listing_create(users, NULL, t, get_name);
return (ui_tab_t *)t;
}
gboolean
egg_sorted_hash_insert (EggSortedHash *hash,
gpointer key,
gpointer value,
guint *position)
{
GSequenceIter *it;
if (g_hash_table_contains (hash->iters, key))
{
if (hash->key_free_func)
hash->key_free_func (key);
if (hash->value_free_func)
hash->value_free_func (value);
return FALSE;
}
if (hash->sort_func)
it = g_sequence_insert_sorted (hash->items, value, hash->sort_func, hash->sort_func_data);
else
it = g_sequence_append (hash->items, value);
g_hash_table_insert (hash->iters, key, it);
if (position)
*position = g_sequence_iter_get_position (it);
return TRUE;
}
static void
bt_pattern_list_model_add (BtPatternListModel * model, BtCmdPattern * pattern)
{
GSequence *seq = model->priv->seq;
GtkTreePath *path;
GtkTreeIter iter;
gint position;
// check if pattern is internal
if (model->priv->skip_internal) {
if (!BT_IS_PATTERN (pattern)) {
GST_INFO ("not adding internal pattern to model");
return;
}
}
GST_INFO ("add pattern to model");
// insert new entry
iter.stamp = model->priv->stamp;
iter.user_data =
g_sequence_insert_sorted (seq, pattern, model_item_cmp, NULL);
position = g_sequence_iter_get_position (iter.user_data);
g_signal_connect_object (pattern, "notify::name",
G_CALLBACK (on_pattern_name_changed), (gpointer) model, 0);
// signal to the view/app
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, position);
gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
GST_DEBUG ("inserted pattern %p at position %d", pattern, position);
}
static void
photos_base_manager_default_add_object (PhotosBaseManager *self, GObject *object)
{
PhotosBaseManagerPrivate *priv;
GObject *old_object;
GSequenceIter *iter;
PhotosBaseManagerObjectData *object_data;
const gchar *id;
guint position;
priv = photos_base_manager_get_instance_private (self);
id = photos_filterable_get_id (PHOTOS_FILTERABLE (object));
old_object = photos_base_manager_get_object_by_id (self, id);
if (old_object != NULL)
return;
if (priv->sort_func == NULL)
{
position = photos_base_manager_get_objects_count (self);
iter = g_sequence_append (priv->sequence, g_object_ref (object));
}
else
{
iter = g_sequence_insert_sorted (priv->sequence, g_object_ref (object), priv->sort_func, priv->sort_data);
position = g_sequence_iter_get_position (iter);
}
object_data = photos_base_manager_object_data_new (object, iter);
g_hash_table_insert (priv->objects, g_strdup (id), object_data);
photos_base_manager_objects_changed (self, position, 0, 1);
g_signal_emit (self, signals[OBJECT_ADDED], 0, object);
}
void event_queue_enqueue(event_queue *queue, guint time, void (*func)(guint, void *), void *data)
{
event_queue_entry *entry = g_slice_alloc0(sizeof(event_queue_entry));
entry->time = time;
entry->func = func;
entry->data = data;
g_sequence_insert_sorted(queue->queue, entry, (gint (*)(gconstpointer,
gconstpointer, gpointer)) event_queue_entry_compare, NULL);
}
void splittable_collection_splittable_connect_child_added_handler(SplittableCollection * sc, GtkSplittable * splittable)
{
GSequenceIter * i = g_sequence_find(sc -> splittables, splittable, compare_pointers, NULL);
if (i == NULL){
g_sequence_insert_sorted(sc -> splittables, splittable, compare_pointers, NULL);
g_signal_connect(
G_OBJECT(splittable), "child-add",
G_CALLBACK(splittable_collection_splittable_child_add_cb), sc);
}
}
/* Iterator that add key-value pairs to a sequence. */
void accumulator (gpointer key, gpointer value, gpointer user_data)
{
GSequence *seq = (GSequence *) user_data;
Pair *pair = g_new(Pair, 1);
pair->word = (gchar *) key;
pair->freq = * (gint *) value;
g_sequence_insert_sorted (seq,
(gpointer) pair,
(GCompareDataFunc) compare_pair,
NULL);
}
Leaf * leaf_new ( int x, int y, int w, int h )
{
Leaf * leaf = malloc( sizeof( Leaf ) );
leaf->x = x;
leaf->y = y;
leaf->w = w;
leaf->h = h;
leaf->area = w * h;
g_sequence_insert_sorted( leaves_sorted_by_area, leaf, leaf_compare, AREA );
return leaf;
}
static gboolean
idle_populate_proposals (GscProviderDevhelp *devhelp)
{
guint idx = 0;
if (devhelp->priv->view == NULL)
{
devhelp->priv->proposals = g_sequence_new ((GDestroyNotify)g_object_unref);
devhelp->priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
devhelp->priv->view = dh_assistant_view_new ();
gtk_widget_show (devhelp->priv->view);
gtk_container_add (GTK_CONTAINER (devhelp->priv->scrolled_window),
devhelp->priv->view);
dh_assistant_view_set_base (DH_ASSISTANT_VIEW (devhelp->priv->view),
devhelp->priv->dhbase);
gtk_widget_set_size_request (devhelp->priv->scrolled_window,
400, 300);
devhelp->priv->populateptr = dh_base_get_keywords (devhelp->priv->dhbase);
}
while (idx < POPULATE_BATCH && devhelp->priv->populateptr)
{
DhLink *link = (DhLink *)devhelp->priv->populateptr->data;
gchar const *name = dh_link_get_name (link);
if (valid_link_type (dh_link_get_link_type (link)) &&
name != NULL && *name != '\0')
{
GscDevhelpItem *proposal = g_object_new (gsc_devhelp_item_get_type (),
NULL);
proposal->link = link;
proposal->word = string_for_compare (dh_link_get_name (proposal->link));
g_sequence_insert_sorted (devhelp->priv->proposals,
proposal,
(GCompareDataFunc)compare_two_items,
NULL);
}
++idx;
devhelp->priv->populateptr = g_list_next (devhelp->priv->populateptr);
}
return devhelp->priv->populateptr != NULL;
}
/**
* @brief Add a new alarm to the queue.
*
* @param id
* @param calendar_time
* @param expiry
* @param serviceName
* @param applicationName
*
* @retval
*/
static bool
alarm_queue_add(uint32_t id, const char *key, bool calendar_time,
time_t expiry, const char *serviceName,
const char *applicationName,
bool subscribe, LSMessage *message)
{
_Alarm *alarm = g_new0(_Alarm, 1);
alarm->key = g_strdup(key);
alarm->id = id;
alarm->calendar = calendar_time;
alarm->expiry = expiry;
alarm->serviceName = g_strdup(serviceName);
alarm->applicationName = g_strdup(applicationName);
if (subscribe)
{
LSError lserror;
LSErrorInit(&lserror);
bool retVal = LSSubscriptionAdd(
GetLunaServiceHandle(), "alarm", message, &lserror);
if (!retVal)
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
goto error;
}
LSMessageRef(message);
alarm->message = message;
}
alarm_print(alarm);
if (alarm->id >= gAlarmQueue->seq_id)
{
gAlarmQueue->seq_id = alarm->id + 1;
}
g_sequence_insert_sorted(gAlarmQueue->alarms,
alarm, (GCompareDataFunc)alarm_cmp_func,
NULL);
update_alarms();
return true;
error:
return false;
}
// 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
g_file_monitor_source_add_pending_change (GFileMonitorSource *fms,
const gchar *child,
gint64 now)
{
PendingChange *change;
GSequenceIter *iter;
change = g_slice_new (PendingChange);
change->child = g_strdup (child);
change->last_emission = now;
change->dirty = FALSE;
iter = g_sequence_insert_sorted (fms->pending_changes, change, pending_change_compare_ready_time, fms);
g_hash_table_insert (fms->pending_changes_table, change->child, iter);
}
static void
add_dummy_row (FMListModel *model, FileEntry *parent_entry)
{
FileEntry *dummy_file_entry;
GtkTreeIter iter;
GtkTreePath *path;
dummy_file_entry = g_new0 (FileEntry, 1);
dummy_file_entry->parent = parent_entry;
dummy_file_entry->ptr = g_sequence_insert_sorted (parent_entry->files, dummy_file_entry,
fm_list_model_file_entry_compare_func, model);
iter.stamp = model->details->stamp;
iter.user_data = dummy_file_entry->ptr;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
}
gboolean bluesky_rangeset_insert(BlueSkyRangeset *rangeset,
uint64_t start, uint64_t length,
gpointer data)
{
GSequenceIter *i;
i = g_sequence_search(rangeset->seq, &start, compare64, NULL);
i = g_sequence_iter_prev(i);
/* TODO: Checks that no other item overlaps. */
BlueSkyRangesetItem *item = g_new(BlueSkyRangesetItem, 1);
item->start = start;
item->length = length;
item->data = data;
g_sequence_insert_sorted(rangeset->seq, item, compare64, NULL);
return TRUE;
}
/**
* ide_debugger_address_map_insert:
* @self: a #IdeDebuggerAddressMap
* @map: the map entry to insert
*
* Inserts a new map entry as specified by @entry.
*
* The contents of @entry are copied and therefore do not need to be kept
* around after calling this function.
*
* See also: ide_debugger_address_map_remove()
*
* Since: 3.32
*/
void
ide_debugger_address_map_insert (IdeDebuggerAddressMap *self,
const IdeDebuggerAddressMapEntry *entry)
{
IdeDebuggerAddressMapEntry real = { 0 };
g_return_if_fail (self != NULL);
g_return_if_fail (entry != NULL);
real.filename = g_string_chunk_insert_const (self->chunk, entry->filename);
real.start = entry->start;
real.end = entry->end;
real.offset = entry->offset;
g_sequence_insert_sorted (self->seq,
g_slice_dup (IdeDebuggerAddressMapEntry, &real),
ide_debugger_address_map_entry_compare,
NULL);
}
static void
gst_timed_value_control_source_set_internal (GstTimedValueControlSource *
self, GstClockTime timestamp, const gdouble value)
{
GstControlPoint *cp;
g_mutex_lock (&self->lock);
/* check if a control point for the timestamp already exists */
if (G_LIKELY (self->values)) {
GSequenceIter *iter = g_sequence_lookup (self->values, ×tamp,
(GCompareDataFunc) gst_control_point_find, NULL);
if (iter) {
GstControlPoint *cp = g_sequence_get (iter);
/* update control point */
cp->value = value;
g_mutex_unlock (&self->lock);
g_signal_emit (self,
gst_timed_value_control_source_signals[VALUE_CHANGED_SIGNAL], 0, cp);
goto done;
}
} else {
self->values = g_sequence_new ((GDestroyNotify) gst_control_point_free);
GST_INFO ("create new timed value sequence");
}
/* sort new cp into the prop->values list */
cp = _make_new_cp (self, timestamp, value);
g_sequence_insert_sorted (self->values, cp,
(GCompareDataFunc) gst_control_point_compare, NULL);
self->nvalues++;
g_mutex_unlock (&self->lock);
g_signal_emit (self,
gst_timed_value_control_source_signals[VALUE_ADDED_SIGNAL], 0, cp);
done:
self->valid_cache = FALSE;
}
void _fm_folder_model_insert_item(FmFolder* dir,
FmFolderItem* new_item,
FmFolderModel* model)
{
GList* l;
GtkTreeIter it;
GtkTreePath* path;
FmFolderItem* item;
FmFileInfo* file = new_item->inf;
GSequenceIter *item_it = g_sequence_insert_sorted(model->items, new_item, fm_folder_model_compare, model);
new_item->iter = item_it;
new_item->iter_age = model->iter_age;
it.stamp = model->stamp;
it.user_data = item_it;
path = gtk_tree_path_new_from_indices(g_sequence_iter_get_position(item_it), -1);
gtk_tree_model_row_inserted(GTK_TREE_MODEL(model), path, &it);
gtk_tree_path_free(path);
}
void
desktop_file_index_text_index_add_ids (GSequence *text_index,
const gchar *token,
const guint16 *ids,
gint n_ids)
{
DesktopFileIndexTextIndexItem *item;
GSequenceIter *iter;
iter = g_sequence_lookup (text_index, &token, desktop_file_index_text_index_string_compare, NULL);
if (iter)
{
item = g_sequence_get (iter);
}
else
{
item = desktop_file_index_text_index_item_new (token);
g_sequence_insert_sorted (text_index, item, desktop_file_index_text_index_string_compare, NULL);
}
desktop_file_index_id_list_add_ids (item->id_list, ids, n_ids);
}
gboolean
fm_ogl_model_add_file (FMOGLModel *model, NautilusFile *file,
NautilusDirectory *directory)
{
FileEntry *file_entry;
GSequence *files;
file_entry = g_new0 (FileEntry, 1);
file_entry->file = nautilus_file_ref (file);
file_entry->parent = NULL;
file_entry->subdirectory = NULL;
file_entry->files = NULL;
files = model->details->files;
file_entry->ptr = g_sequence_insert_sorted (files, file_entry,
fm_ogl_model_file_entry_compare_func, model);
return TRUE;
}
/*
* 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 sorted_sequence_insert(SortedSequence * sequence, gpointer data)
{
g_sequence_insert_sorted(sequence -> seq, data, sequence -> cmp_func, NULL);
}
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);
}
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;
}
static void rclib_lyric_add_line(RCLibLyricParsedData *parsed_data,
GRegex *regex, const gchar *encoding, const gchar *line, gsize length)
{
GMatchInfo *match_info;
gchar *tmp;
gchar *lyric_line;
gsize bytes_read, bytes_written;
gint minute = 0;
gfloat second = 0.0;
gint64 time;
gchar *str;
gint value;
gchar *text = NULL;
GArray *time_array;
gint i;
RCLibLyricData *lyric_data;
if(parsed_data==NULL || regex==NULL || line==NULL) return;
if(g_utf8_validate(line, length, NULL))
lyric_line = g_strdup(line);
else if(encoding!=NULL)
{
tmp = g_convert(line, length, "UTF-8", encoding, &bytes_read,
&bytes_written, NULL);
if(tmp==NULL) return;
lyric_line = tmp;
}
else return;
if(!g_regex_match(regex, lyric_line, 0, &match_info))
{
g_free(lyric_line);
return;
}
time_array = g_array_new(FALSE, FALSE, sizeof(gint64));
while(g_match_info_matches(match_info))
{
str = g_match_info_fetch_named(match_info, "time");
if(str!=NULL && strlen(str)>0)
{
if(sscanf(str, "[%d:%f]", &minute, &second)==2)
{
time = minute * 6000 + (gint)(second * 100);
time *= 10 * GST_MSECOND;
g_array_append_val(time_array, time);
}
}
g_free(str);
str = g_match_info_fetch_named(match_info, "title");
if(str!=NULL)
tmp = g_strstr_len(str, -1, ":");
else
tmp = NULL;
if(tmp!=NULL && strlen(tmp)>2)
{
tmp++;
if(parsed_data->title==NULL)
parsed_data->title = g_strndup(tmp, strlen(tmp)-1);
}
g_free(str);
str = g_match_info_fetch_named(match_info, "artist");
if(str!=NULL)
tmp = g_strstr_len(str, -1, ":");
else
tmp = NULL;
if(tmp!=NULL && strlen(tmp)>2)
{
tmp++;
if(parsed_data->artist==NULL)
parsed_data->artist = g_strndup(tmp, strlen(tmp)-1);
}
g_free(str);
str = g_match_info_fetch_named(match_info, "album");
if(str!=NULL)
tmp = g_strstr_len(str, -1, ":");
else
tmp = NULL;
if(tmp!=NULL && strlen(tmp)>2)
{
tmp++;
if(parsed_data->album==NULL)
parsed_data->album = g_strndup(tmp, strlen(tmp)-1);
}
g_free(str);
str = g_match_info_fetch_named(match_info, "author");
if(str!=NULL)
tmp = g_strstr_len(str, -1, ":");
else
tmp = NULL;
if(tmp!=NULL && strlen(tmp)>2)
{
tmp++;
if(parsed_data->author==NULL)
parsed_data->author = g_strndup(tmp, strlen(tmp)-1);
}
g_free(str);
str = g_match_info_fetch_named(match_info, "offset");
if(str!=NULL)
tmp = g_strstr_len(str, -1, ":");
else
tmp = NULL;
if(tmp!=NULL && strlen(tmp)>2)
{
tmp++;
if(sscanf(tmp, "%d", &value)==1)
parsed_data->offset = value;
}
g_free(str);
str = g_match_info_fetch_named(match_info, "text");
if(str!=NULL && strlen(str)>0)
{
text = g_strdup(str);
}
g_free(str);
g_match_info_next(match_info, NULL);
}
if(text==NULL) text = g_strdup("");
for(i=0;i<time_array->len;i++)
{
lyric_data = g_new0(RCLibLyricData, 1);
lyric_data->time = g_array_index(time_array, gint64, i);
lyric_data->length = -1;
lyric_data->text = g_strdup(text);
g_sequence_insert_sorted(parsed_data->seq, lyric_data,
rclib_lyric_time_compare_func, NULL);
}
g_free(text);
g_array_free(time_array, TRUE);
g_free(lyric_line);
}
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;
}
