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