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; }
extern power_supply* power_supply_new() { power_supply* tmp = g_new(power_supply, 1); tmp->ac_list = g_sequence_new(&ac_free); tmp->bat_list = g_sequence_new(&bat_free); return tmp; }
void fm_folder_model_set_folder(FmFolderModel* model, FmFolder* dir) { GSequenceIter *it; if( model->dir == dir ) return; model->iter_age++; if( model->dir ) { g_signal_handlers_disconnect_by_func(model->dir, _fm_folder_model_files_added, model); g_signal_handlers_disconnect_by_func(model->dir, _fm_folder_model_files_removed, model); g_signal_handlers_disconnect_by_func(model->dir, _fm_folder_model_files_changed, model); g_signal_handlers_disconnect_by_func(model->dir, on_folder_loaded, model); g_sequence_free(model->items); g_sequence_free(model->hidden); g_object_unref(model->dir); } model->dir = dir; model->items = g_sequence_new((GDestroyNotify)fm_folder_item_free); model->hidden = g_sequence_new((GDestroyNotify)fm_folder_item_free); if( !dir ) return; model->dir = (FmFolder*)g_object_ref(model->dir); g_signal_connect(model->dir, "files-added", G_CALLBACK(_fm_folder_model_files_added), model); g_signal_connect(model->dir, "files-removed", G_CALLBACK(_fm_folder_model_files_removed), model); g_signal_connect(model->dir, "files-changed", G_CALLBACK(_fm_folder_model_files_changed), model); g_signal_connect(model->dir, "loaded", G_CALLBACK(on_folder_loaded), model); if( !fm_list_is_empty(dir->files) ) { GList *l; for( l = fm_list_peek_head_link(dir->files); l; l = l->next ) _fm_folder_model_add_file(model, (FmFileInfo*)l->data); } if( fm_folder_get_is_loaded(model->dir) ) /* if it's already loaded */ on_folder_loaded(model->dir, model); /* emit 'loaded' signal */ }
static void swfdec_text_buffer_init (SwfdecTextBuffer *buffer) { buffer->text = g_string_new (""); buffer->attributes = g_sequence_new ((GDestroyNotify) swfdec_text_buffer_format_free); swfdec_text_attributes_reset (&buffer->default_attributes); }
// Called when the hub is disconnected. All users should be removed in one go, // this is faster than a _userchange() for every user. void uit_userlist_disconnect(ui_tab_t *tab) { tab_t *t = (tab_t *)tab; g_sequence_free(t->list->list); ui_listing_free(t->list); t->list = ui_listing_create(g_sequence_new(NULL), NULL, t, get_name); }
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; }
SortedSequence * sorted_sequence_new(GDestroyNotify data_destroy, GCompareDataFunc cmp_func) { SortedSequence * sorted_sequence = g_object_new(GOSM_TYPE_SORTED_SEQUENCE, NULL); sorted_sequence -> seq = g_sequence_new(data_destroy); sorted_sequence -> cmp_func = cmp_func; return sorted_sequence; }
/* Filesystem-level operations. A filesystem is like a directory tree that we * are willing to export. */ BlueSkyFS *bluesky_new_fs(gchar *name) { BlueSkyFS *fs = g_new0(BlueSkyFS, 1); fs->lock = g_mutex_new(); fs->name = g_strdup(name); fs->inodes = g_hash_table_new(bluesky_fs_key_hash_func, bluesky_fs_key_equal_func); fs->next_inum = BLUESKY_ROOT_INUM + 1; fs->store = bluesky_store_new("file"); fs->flushd_lock = g_mutex_new(); fs->flushd_cond = g_cond_new(); fs->locations = g_hash_table_new(bluesky_cloudlog_hash, bluesky_cloudlog_equal); fs->inode_map = g_sequence_new(NULL); fs->log_state = g_new0(BlueSkyCloudLogState, 1); fs->log_state->data = g_string_new(""); fs->log_state->latest_cleaner_seq_seen = -1; fs->log_state->uploads_pending_lock = g_mutex_new(); fs->log_state->uploads_pending_cond = g_cond_new(); bluesky_cloudlog_threads_init(fs); fs->inode_fetch_thread_pool = g_thread_pool_new(inode_fetch_task, NULL, bluesky_max_threads, FALSE, NULL); return fs; }
int main (int argc, char** argv) { gchar *filename; // open the file if (argc > 1) { filename = argv[1]; } else { filename = "emma.txt"; } FILE *fp = g_fopen(filename, "r"); if (fp == NULL) { perror (filename); exit (-10); } /* string array is a (two-L) NULL terminated array of pointers to (one-L) NUL terminated strings */ gchar **array; gchar line[128]; GHashTable* hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); int i; // read lines from the file and build the hash table while (1) { gchar *res = fgets (line, sizeof(line), fp); if (res == NULL) break; array = g_strsplit (line, " ", 0); for (i=0; array[i] != NULL; i++) { incr (hash, array[i]); } g_strfreev (array); } fclose (fp); // print the hash table // g_hash_table_foreach (hash, (GHFunc) kv_printor, "Word %s freq %d\n"); // iterate the hash table and build the sequence GSequence *seq = g_sequence_new ((GDestroyNotify) pair_destructor); g_hash_table_foreach (hash, (GHFunc) accumulator, (gpointer) seq); // iterate the sequence and print the pairs g_sequence_foreach (seq, (GFunc) pair_printor, NULL); // free everything g_hash_table_destroy (hash); g_sequence_free (seq); return 0; }
static IsStoreEntry * entry_new(const gchar *name) { IsStoreEntry *entry = g_slice_new0(IsStoreEntry); entry->name = g_strdup(name); entry->entries = g_sequence_new((GDestroyNotify)entry_free); return entry; }
struct segment* new_segment() { struct segment * s = (struct segment*) malloc(sizeof(struct segment)); s->id = TEMPORARY_ID; s->chunk_num = 0; s->chunks = g_sequence_new(NULL); s->features = NULL; return s; }
static GSequence* _sequence_new (gchar *data) { GSequence *value = NULL; value = g_sequence_new (NULL); g_sequence_append (value, (guint8 *)data); return value; }
RmOffsetTable rm_offset_create_table(const char *path) { int fd = rm_sys_open(path, O_RDONLY); if(fd == -1) { rm_log_info("Error opening %s in setup_fiemap_extents\n", path); return NULL; } /* struct fiemap does not allocate any extents by default, * so we choose ourself how many of them we allocate. * */ const int n_extents = 256; struct fiemap *fiemap = g_malloc0(sizeof(struct fiemap) + n_extents * sizeof(struct fiemap_extent)); struct fiemap_extent *fm_ext = fiemap->fm_extents; /* data structure we save our offsets in */ GSequence *self = g_sequence_new((GFreeFunc)rm_offset_free_func); bool last = false; while(!last) { fiemap->fm_flags = 0; fiemap->fm_extent_count = n_extents; fiemap->fm_length = FIEMAP_MAX_OFFSET; if(ioctl(fd, FS_IOC_FIEMAP, (unsigned long) fiemap) == -1) { break; } /* This might happen on empty files - those have no * extents, but they have an offset on the disk. */ if(fiemap->fm_mapped_extents <= 0) { break; } /* used for detecting contiguous extents, which we ignore */ unsigned long expected = 0; /* Remember all non contiguous extents */ for(unsigned i = 0; i < fiemap->fm_mapped_extents && !last; i++) { if (i == 0 || fm_ext[i].fe_physical != expected) { RmOffsetEntry *offset_entry = g_slice_new(RmOffsetEntry); offset_entry->logical = fm_ext[i].fe_logical; offset_entry->physical = fm_ext[i].fe_physical; g_sequence_append(self, offset_entry); } expected = fm_ext[i].fe_physical + fm_ext[i].fe_length; fiemap->fm_start = fm_ext[i].fe_logical + fm_ext[i].fe_length; last = fm_ext[i].fe_flags & FIEMAP_EXTENT_LAST; } } rm_sys_close(fd); g_free(fiemap); g_sequence_sort(self, (GCompareDataFunc)rm_offset_sort_logical, NULL); return self; }
static void lbmc_stream_dlg_reset_stream_table(lbmc_stream_dlg_info_t * info) { if (info->stream_table != NULL) { g_sequence_free(info->stream_table); info->stream_table = NULL; } info->stream_table = g_sequence_new(lbmc_stream_dlg_stream_entry_destroy_cb); }
static void g_dbus_menu_group_changed (GDBusMenuGroup *group, guint menu_id, gint position, gint removed, GVariant *added) { GSequenceIter *point; GVariantIter iter; GDBusMenuModel *proxy; GSequence *items; GVariant *item; gint n_added; /* We could have signals coming to us when we're not active (due to * some other process having subscribed to this group) or when we're * pending. In both of those cases, we want to ignore the signal * since we'll get our own information when we call "Start" for * ourselves. */ if (group->state != GROUP_ONLINE) return; items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id)); if (items == NULL) { items = g_sequence_new (g_dbus_menu_model_item_free); g_hash_table_insert (group->menus, GINT_TO_POINTER (menu_id), items); } point = g_sequence_get_iter_at_pos (items, position + removed); g_return_if_fail (point != NULL); if (removed) { GSequenceIter *start; start = g_sequence_get_iter_at_pos (items, position); g_sequence_remove_range (start, point); } n_added = g_variant_iter_init (&iter, added); while (g_variant_iter_loop (&iter, "@a{sv}", &item)) g_sequence_insert_before (point, g_dbus_menu_group_create_item (item)); if (g_sequence_get_length (items) == 0) { g_hash_table_remove (group->menus, GINT_TO_POINTER (menu_id)); items = NULL; } if ((proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id)))) g_dbus_menu_model_changed (proxy, items, position, removed, n_added); }
static void ide_recent_projects_init (IdeRecentProjects *self) { self->projects = g_sequence_new (g_object_unref); self->recent_uris = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); self->file_uri = g_build_filename (g_get_user_data_dir (), ide_get_program_name (), IDE_RECENT_PROJECTS_BOOKMARK_FILENAME, NULL); }
GtkWidget * splittable_collection_new() { SplittableCollection * sc = g_object_new(VEX_TYPE_SPLITTABLE_COLLECTION, NULL); sc -> descendents_to_splittables = g_map_new(compare_pointers, NULL); sc -> splittables = g_sequence_new(NULL); sc -> focussed_descendent = NULL; return GTK_WIDGET(sc); }
static void fm_ogl_model_init (FMOGLModel *model) { model->details = g_new0 (FMOGLModelDetails, 1); model->details->files = g_sequence_new ((GDestroyNotify)file_entry_free); model->details->top_reverse_map = g_hash_table_new (g_direct_hash, g_direct_equal); model->details->directory_reverse_map = g_hash_table_new (g_direct_hash, g_direct_equal); model->details->stamp = g_random_int (); model->details->sort_attribute = 0; }
/** * ide_debugger_address_map: * * Creates a new #IdeDebuggerAddressMap. * * The map is used to track the locations of mapped files in the inferiors * address space. This allows relatively quick lookup to determine what file * contains a given execution address (instruction pointer, etc). * * See also: ide_debugger_address_map_free() * * Returns: (transfer full): A new #IdeDebuggerAddressMap * * Since: 3.32 */ IdeDebuggerAddressMap * ide_debugger_address_map_new (void) { IdeDebuggerAddressMap *ret; ret = g_slice_new0 (IdeDebuggerAddressMap); ret->seq = g_sequence_new (ide_debugger_address_map_entry_free); ret->chunk = g_string_chunk_new (4096); return ret; }
static void is_store_init(IsStore *self) { IsStorePrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE(self, IS_TYPE_STORE, IsStorePrivate); self->priv = priv; priv->entries = g_sequence_new((GDestroyNotify)entry_free); priv->stamp = g_random_int(); }
static void rclib_lyric_instance_init(RCLibLyric *lyric) { RCLibLyricPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE(lyric, RCLIB_TYPE_LYRIC, RCLibLyricPrivate); lyric->priv = priv; priv->parsed_data1.seq = g_sequence_new((GDestroyNotify) rclib_lyric_lyric_data_free); priv->parsed_data2.seq = g_sequence_new((GDestroyNotify) rclib_lyric_lyric_data_free); priv->regex = g_regex_new("(?P<time>\\[[0-9]+:[0-9]+([\\.:][0-9]+)*\\])|" "(?P<text>[^\\]]*$)|(?P<title>\\[ti:.+\\])|(?P<artist>\\[ar:.+\\])|" "(?P<album>\\[al:.+\\])|(?P<author>\\[by:.+\\])|" "(?P<offset>\\[offset:.+\\])", 0, 0, NULL); priv->timer = g_timeout_add(100, (GSourceFunc)rclib_lyric_watch_timer, NULL); priv->tag_found_handler = rclib_core_signal_connect("tag-found", G_CALLBACK(rclib_lyric_tag_found_cb), lyric); priv->uri_changed_handler = rclib_core_signal_connect("uri-changed", G_CALLBACK(rclib_lyric_uri_changed_cb), lyric); }
static void bt_pattern_list_model_init (BtPatternListModel * self) { self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, BT_TYPE_PATTERN_LIST_MODEL, BtPatternListModelPrivate); self->priv->seq = g_sequence_new (NULL); // random int to check whether an iter belongs to our model self->priv->stamp = g_random_int (); }
static void clutter_list_model_init (ClutterListModel *model) { model->priv = CLUTTER_LIST_MODEL_GET_PRIVATE (model); model->priv->sequence = g_sequence_new (NULL); model->priv->temp_iter = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER, "model", model, NULL); }
static int alarm_queue_create(void) { gAlarmQueue = g_new0(_AlarmQueue, 1); gAlarmQueue->alarms = g_sequence_new((GDestroyNotify)alarm_free); gAlarmQueue->seq_id = 0; gAlarmQueue->alarm_db = g_build_filename(PREFERENCE_DIR, "alarms.xml", NULL); return 0; }
static int alarm_queue_create(void) { gAlarmQueue = g_new0(_AlarmQueue, 1); gAlarmQueue->alarms = g_sequence_new((GDestroyNotify)alarm_free); gAlarmQueue->seq_id = 0; gAlarmQueue->alarm_db = g_build_filename(gSleepConfig.preference_dir, "alarms.xml", NULL); return 0; }
static void gst_rtsp_mount_points_init (GstRTSPMountPoints * mounts) { GstRTSPMountPointsPrivate *priv = GST_RTSP_MOUNT_POINTS_GET_PRIVATE (mounts); GST_DEBUG_OBJECT (mounts, "created"); mounts->priv = priv; g_mutex_init (&priv->lock); priv->mounts = g_sequence_new (data_item_free); priv->dirty = FALSE; }
static void photos_base_manager_init (PhotosBaseManager *self) { PhotosBaseManagerPrivate *priv; priv = photos_base_manager_get_instance_private (self); priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) photos_base_manager_object_data_free); priv->sequence = g_sequence_new (g_object_unref); priv->last_position = G_MAXUINT; }
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; }
static void rhythmdb_property_model_init (RhythmDBPropertyModel *model) { model->priv = RHYTHMDB_PROPERTY_MODEL_GET_PRIVATE (model); model->priv->stamp = g_random_int (); model->priv->properties = g_sequence_new (NULL); model->priv->reverse_map = g_hash_table_new (g_str_hash, g_str_equal); model->priv->entries = g_hash_table_new (g_direct_hash, g_direct_equal); model->priv->all = g_new0 (RhythmDBPropertyModelEntry, 1); model->priv->all->string = rb_refstring_new (_("All")); model->priv->sort_propids = g_array_new (FALSE, FALSE, sizeof (RhythmDBPropType)); }
EggSortedHash * egg_sorted_hash_new (GHashFunc hash_func, GEqualFunc equal_func, GDestroyNotify key_free_func, GDestroyNotify value_free_func) { EggSortedHash *hash; hash = g_new0 (EggSortedHash, 1); hash->items = g_sequence_new (value_free_func); hash->iters = g_hash_table_new_full (hash_func, equal_func, key_free_func, NULL); hash->key_free_func = key_free_func; hash->value_free_func = value_free_func; return hash; }