static void rclib_lyric_finalize(GObject *object)
{
RCLibLyricPrivate *priv = RCLIB_LYRIC(object)->priv;
RCLIB_LYRIC(object)->priv = NULL;
if(priv->tag_found_handler>0)
rclib_core_signal_disconnect(priv->tag_found_handler);
if(priv->uri_changed_handler>0)
rclib_core_signal_disconnect(priv->uri_changed_handler);
if(priv->regex!=NULL) g_regex_unref(priv->regex);
g_free(priv->search_dir);
g_free(priv->encoding);
if(priv->parsed_data1.seq!=NULL) g_sequence_free(priv->parsed_data1.seq);
g_free(priv->parsed_data1.filename);
g_free(priv->parsed_data1.title);
g_free(priv->parsed_data1.artist);
g_free(priv->parsed_data1.album);
g_free(priv->parsed_data1.author);
if(priv->parsed_data2.seq!=NULL) g_sequence_free(priv->parsed_data2.seq);
g_free(priv->parsed_data2.filename);
g_free(priv->parsed_data2.title);
g_free(priv->parsed_data2.artist);
g_free(priv->parsed_data2.album);
g_free(priv->parsed_data2.author);
g_source_remove(priv->timer);
G_OBJECT_CLASS(rclib_lyric_parent_class)->finalize(object);
}
void rm_userlist_destroy(RmUserList *self) {
g_assert(self);
g_sequence_free(self->users);
g_sequence_free(self->groups);
g_mutex_clear(&self->mutex);
g_free(self);
}
void rm_userlist_destroy(RmUserList *self) {
rm_assert_gentle(self);
g_sequence_free(self->users);
g_sequence_free(self->groups);
g_mutex_clear(&self->lock);
g_free(self);
}
extern void
power_supply_free(gpointer p) {
power_supply* tmp = (power_supply*) p;
g_sequence_free(tmp->ac_list);
g_sequence_free(tmp->bat_list);
g_free(tmp);
if (DEBUG) {
g_fprintf(stderr, "power_supply_free %p\n", p);
}
}
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
rhythmdb_property_model_finalize (GObject *object)
{
RhythmDBPropertyModel *model;
g_return_if_fail (object != NULL);
g_return_if_fail (RHYTHMDB_IS_PROPERTY_MODEL (object));
model = RHYTHMDB_PROPERTY_MODEL (object);
rb_debug ("finalizing property model %p", model);
g_return_if_fail (model->priv != NULL);
g_hash_table_destroy (model->priv->reverse_map);
g_sequence_foreach (model->priv->properties, (GFunc)_prop_model_entry_cleanup, NULL);
g_sequence_free (model->priv->properties);
g_hash_table_destroy (model->priv->entries);
g_free (model->priv->all);
g_array_free (model->priv->sort_propids, TRUE);
G_OBJECT_CLASS (rhythmdb_property_model_parent_class)->finalize (object);
}
// 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);
}
/**
* @brief Free any memory associated with a scheduler_t.
*
* This will stop the interface if it is currently running, and free all the
* memory associated with the different regular expression and similar
* structures.
*
* @param scheduler
*/
void scheduler_destroy(scheduler_t* scheduler)
{
// TODO interface close
// TODO repo close
event_loop_destroy();
if(scheduler->main_log)
{
log_destroy(scheduler->main_log);
main_log = NULL;
}
if(scheduler->process_name) g_free(scheduler->process_name);
if(scheduler->sysconfig) fo_config_free(scheduler->sysconfig);
if(scheduler->sysconfigdir) g_free(scheduler->sysconfigdir);
if(scheduler->host_queue) g_list_free(scheduler->host_queue);
if(scheduler->workers) g_thread_pool_free(scheduler->workers, FALSE, TRUE);
if(scheduler->email_subject) g_free(scheduler->email_subject);
if(scheduler->email_command) g_free(scheduler->email_command);
g_sequence_free(scheduler->job_queue);
g_regex_unref(scheduler->parse_agent_msg);
g_regex_unref(scheduler->parse_db_email);
g_regex_unref(scheduler->parse_interface_cmd);
g_tree_unref(scheduler->meta_agents);
g_tree_unref(scheduler->agents);
g_tree_unref(scheduler->host_list);
g_tree_unref(scheduler->job_list);
g_free(scheduler);
}
void free_all() {
gtk_widget_destroy(combo);
g_object_unref(raster);
g_key_file_free(settings);
g_tree_destroy(pintable);
g_sequence_free(dictionary);
}
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;
}
void
egg_sorted_hash_free (EggSortedHash *hash)
{
g_hash_table_unref (hash->iters);
g_sequence_free (hash->items);
g_free (hash);
}
static void
gsc_provider_devhelp_finalize (GObject *object)
{
GscProviderDevhelp *provider = GSC_PROVIDER_DEVHELP (object);
g_sequence_free (provider->priv->proposals);
G_OBJECT_CLASS (gsc_provider_devhelp_parent_class)->finalize (object);
}
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
entry_free(IsStoreEntry *entry)
{
if (entry->sensor) {
g_object_unref(entry->sensor);
}
g_sequence_free(entry->entries);
g_free(entry->name);
g_slice_free(IsStoreEntry, entry);
}
/**
* ide_debugger_address_map_free:
* @self: a #IdeDebuggerAddressMap
*
* Frees all memory associated with @self.
*
* Since: 3.32
*/
void
ide_debugger_address_map_free (IdeDebuggerAddressMap *self)
{
if (self != NULL)
{
g_sequence_free (self->seq);
g_string_chunk_free (self->chunk);
g_slice_free (IdeDebuggerAddressMap, self);
}
}
static void
random_menu_finalize (GObject *object)
{
RandomMenu *menu = (RandomMenu *) object;
g_sequence_free (menu->items);
G_OBJECT_CLASS (random_menu_parent_class)
->finalize (object);
}
static void lbmc_stream_dlg_stream_entry_destroy_cb(gpointer data)
{
lbmc_stream_dlg_stream_entry_t * stream = (lbmc_stream_dlg_stream_entry_t *)data;
if (stream->substreams != NULL)
{
g_sequence_free(stream->substreams);
stream->substreams = NULL;
}
g_free(data);
}
static void t_close(ui_tab_t *tab) {
tab_t *t = (tab_t *)tab;
uit_hub_set_userlist(t->tab.hub->tab, NULL);
ui_tab_remove(tab);
// To clean things up, we should also reset all hub_user->iter fields. But
// this isn't all that necessary since they won't be used anymore until they
// get reset in a subsequent ui_userlist_create().
g_sequence_free(t->list->list);
ui_listing_free(t->list);
g_free(t->tab.name);
g_free(t);
}
static void
gst_rtsp_mount_points_finalize (GObject * obj)
{
GstRTSPMountPoints *mounts = GST_RTSP_MOUNT_POINTS (obj);
GstRTSPMountPointsPrivate *priv = mounts->priv;
GST_DEBUG_OBJECT (mounts, "finalized");
g_sequence_free (priv->mounts);
g_mutex_clear (&priv->lock);
G_OBJECT_CLASS (gst_rtsp_mount_points_parent_class)->finalize (obj);
}
static void
is_store_finalize(GObject *object)
{
IsStore *self = (IsStore *)object;
IsStorePrivate *priv = self->priv;
g_sequence_free(priv->entries);
/* Make compiler happy */
(void)priv;
G_OBJECT_CLASS(is_store_parent_class)->finalize(object);
}
int main(int argc, char const *argv[]) {
if(argc < 3) {
return EXIT_FAILURE;
}
GSequence *db = rm_offset_create_table(argv[1]);
RmOff off = rm_offset_lookup(db, g_ascii_strtoll(argv[2], NULL, 10));
rm_log_warning("Offset: %"LLU"\n", off);
g_sequence_free(db);
return EXIT_SUCCESS;
}
static void
swfdec_text_buffer_dispose (GObject *object)
{
SwfdecTextBuffer *buffer = SWFDEC_TEXT_BUFFER (object);
if (buffer->text != NULL) {
g_string_free (buffer->text, TRUE);
buffer->text = NULL;
}
g_sequence_free (buffer->attributes);
swfdec_text_attributes_reset (&buffer->default_attributes);
G_OBJECT_CLASS (swfdec_text_buffer_parent_class)->dispose (object);
}
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
g_menu_exporter_menu_free (GMenuExporterMenu *menu)
{
g_menu_exporter_group_remove_menu (menu->group, menu->id);
if (menu->handler_id != 0)
g_signal_handler_disconnect (menu->model, menu->handler_id);
if (menu->item_links != NULL)
g_sequence_free (menu->item_links);
g_object_unref (menu->model);
g_slice_free (GMenuExporterMenu, menu);
}
void rm_file_destroy(RmFile *file) {
if(file->disk_offsets) {
g_sequence_free(file->disk_offsets);
}
if(file->hardlinks.is_head && file->hardlinks.files) {
g_queue_free_full(file->hardlinks.files, (GDestroyNotify)rm_file_destroy);
}
/* --cache can write cksums in here */
if(file->folder && file->folder->data) {
g_free(file->folder->data);
}
g_slice_free(RmFile, file);
}
static void
byzanz_recorder_finalize (GObject *object)
{
ByzanzRecorder *recorder = BYZANZ_RECORDER (object);
if (recorder->next_image_source)
g_source_remove (recorder->next_image_source);
gdk_window_remove_filter (recorder->window,
byzanz_recorder_filter_events, recorder);
g_object_unref (recorder->window);
g_sequence_free (recorder->layers);
G_OBJECT_CLASS (byzanz_recorder_parent_class)->finalize (object);
}
static void
file_entry_free (FileEntry *file_entry)
{
nemo_file_unref (file_entry->file);
if (file_entry->reverse_map) {
g_hash_table_destroy (file_entry->reverse_map);
file_entry->reverse_map = NULL;
}
if (file_entry->subdirectory != NULL) {
nemo_directory_unref (file_entry->subdirectory);
}
if (file_entry->files != NULL) {
g_sequence_free (file_entry->files);
}
g_free (file_entry);
}
/**
* gst_timed_value_control_source_unset_all:
* @self: the #GstTimedValueControlSource object
*
* Used to remove all time-stamped values of given controller-handled property
*
*/
void
gst_timed_value_control_source_unset_all (GstTimedValueControlSource * self)
{
g_return_if_fail (GST_IS_TIMED_VALUE_CONTROL_SOURCE (self));
g_mutex_lock (&self->lock);
/* free GstControlPoint structures */
if (self->values) {
g_sequence_free (self->values);
self->values = NULL;
}
self->nvalues = 0;
self->valid_cache = FALSE;
g_mutex_unlock (&self->lock);
}
static void
gst_timed_value_control_source_reset (GstTimedValueControlSource * self)
{
GstControlSource *csource = (GstControlSource *) self;
csource->get_value = NULL;
csource->get_value_array = NULL;
if (self->values) {
g_sequence_free (self->values);
self->values = NULL;
}
self->nvalues = 0;
self->valid_cache = FALSE;
}
static void cleanup_session(gpointer user_data)
{
struct connman_session *session = user_data;
struct session_info *info = session->info;
DBG("remove %s", session->session_path);
g_slist_free(session->user_allowed_bearers);
g_hash_table_destroy(session->service_hash);
g_sequence_free(session->service_list);
if (info->entry != NULL &&
info->entry->reason == CONNMAN_SESSION_REASON_CONNECT) {
__connman_service_disconnect(info->entry->service);
}
free_session(session);
}
