static gboolean cloud_config_simplify(GNode *node, __unused__ gpointer data) {
if (node->data) {
return false;
}
GNode *child = g_node_last_child(node);
while (child) {
if (child->data) {
child = g_node_prev_sibling(child);
continue;
}
GNode *remove = child;
child = g_node_prev_sibling(child);
g_node_append(node->parent, g_node_copy(remove));
g_node_unlink(remove);
g_node_destroy(remove);
}
if (g_node_n_children(node) == 0) {
g_node_unlink(node);
g_node_destroy(node);
}
return false;
}
/**
* gts_bb_tree_destroy:
* @tree: a bounding box tree.
* @free_leaves: if %TRUE the bounding boxes given by the user are freed.
*
* Destroys all the bounding boxes created by @tree and destroys the
* tree itself. If @free_leaves is set to %TRUE, destroys boxes given
* by the user when creating the tree (i.e. leaves of the tree).
*/
void gts_bb_tree_destroy (GNode * tree, gboolean free_leaves)
{
g_return_if_fail (tree != NULL);
bb_tree_free (tree, free_leaves);
g_node_destroy (tree);
}
/**
* clutter_score_remove:
* @score: a #ClutterScore
* @id: the id of the timeline to remove
*
* Removes the #ClutterTimeline with the given id inside @score. If
* the timeline has other timelines attached to it, those are removed
* as well.
*
* Since: 0.6
*/
void
clutter_score_remove (ClutterScore *score,
gulong id)
{
ClutterScorePrivate *priv;
TraverseClosure closure;
g_return_if_fail (CLUTTER_IS_SCORE (score));
g_return_if_fail (id > 0);
priv = score->priv;
closure.action = REMOVE_BY_ID;
closure.score = score;
closure.d.id = id;
closure.result = NULL;
g_node_traverse (priv->root,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
traverse_children, &closure);
if (closure.result)
g_node_destroy (closure.result);
}
static void delete_cb (GtkMenuItem *item, gpointer data)
{
GtkWidget *dialog;
int result;
GtkTreeIter iter;
GNode *node;
if (gtk_tree_selection_get_selected (editor->selection,
NULL, &iter) == FALSE )
return;
gtk_tree_model_get (GTK_TREE_MODEL (editor->store), &iter,
COLUMN_ENTRY, &node, -1);
dialog = gtk_message_dialog_new (editor->window, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("Delete bookmark?"));
result = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
switch (result) {
case GTK_RESPONSE_YES:
gtk_tree_store_remove (editor->store, &iter);
g_node_destroy (node);
break;
default:
return;
}
gtk_widget_destroy (dialog);
editor->changed = 1;
gtk_widget_set_sensitive (GTK_WIDGET (editor->save_button), TRUE);
}
xmlResult xml_destroy_document(xmlDoc *doc){
#ifdef XML_TRACE
LOG(LOG_DEBUG, "IN : xml_destroy_document()");
#endif
if(doc == NULL) {
#ifdef XML_TRACE
LOG(LOG_DEBUG, "OUT : xml_destroy_document() : NOP");
#endif
return(XML_OK);
}
xml_destroy_tree_internal(doc->root, NULL);
free(doc->root->data);
g_node_destroy((GNode *)doc->root);
g_free(doc->version);
g_free(doc->encoding);
g_free(doc);
#ifdef XML_TRACE
LOG(LOG_DEBUG, "OUT : xml_destroy_document()");
#endif
return(XML_OK);
}
static void
i7_node_finalize(GObject *self)
{
I7_NODE_USE_PRIVATE;
cairo_pattern_destroy(priv->label_pattern);
cairo_pattern_destroy(priv->node_pattern[NODE_UNPLAYED_UNBLESSED]);
cairo_pattern_destroy(priv->node_pattern[NODE_UNPLAYED_BLESSED]);
cairo_pattern_destroy(priv->node_pattern[NODE_PLAYED_UNBLESSED]);
cairo_pattern_destroy(priv->node_pattern[NODE_PLAYED_BLESSED]);
g_free(priv->command);
g_free(priv->label);
g_free(priv->transcript_text);
g_free(priv->expected_text);
g_free(priv->transcript_pango_string);
g_free(priv->expected_pango_string);
g_free(priv->id);
goo_canvas_points_unref(I7_NODE(self)->tree_points);
g_list_free(priv->transcript_diffs);
g_list_free(priv->expected_diffs);
/* recurse */
g_node_children_foreach(I7_NODE(self)->gnode, G_TRAVERSE_ALL, (GNodeForeachFunc)unref_node, NULL);
/* free the node itself */
g_node_destroy(I7_NODE(self)->gnode);
G_OBJECT_CLASS(i7_node_parent_class)->finalize(self);
}
static gboolean
rspamd_html_check_balance (GNode * node, GNode ** cur_level)
{
struct html_tag *arg = node->data, *tmp;
GNode *cur;
if (arg->flags & FL_CLOSING) {
/* First of all check whether this tag is closing tag for parent node */
cur = node->parent;
while (cur && cur->data) {
tmp = cur->data;
if (tmp->id == arg->id &&
(tmp->flags & FL_CLOSED) == 0) {
tmp->flags |= FL_CLOSED;
/* Destroy current node as we find corresponding parent node */
g_node_destroy (node);
/* Change level */
*cur_level = cur->parent;
return TRUE;
}
cur = cur->parent;
}
}
else {
return TRUE;
}
return FALSE;
}
/** Calls the destructor on every element of the tree. */
void
destroy(GNode* root)
{
g_debug("Destroying %p...", root);
g_node_traverse(root, G_POST_ORDER, G_TRAVERSE_ALL, -1, destroy_, NULL);
g_node_destroy(root);
}
void bot_destroy(BOT_REC *bot)
{
GNode *node;
g_return_if_fail(bot != NULL);
node = g_node_find(bot->botnet->bots, 0, G_TRAVERSE_ALL, bot);
if (node != NULL) {
if (!bot->disconnect)
bot_mark_disconnects(node);
}
bot_disconnect(bot);
if (node != NULL) {
while (node->children != NULL)
bot_destroy(node->children->data);
g_node_destroy(node);
}
if (bot->botnet->uplink == bot)
bot->botnet->uplink = NULL;
if (bot->botnet->master == bot)
bot->botnet->master = NULL;
while (bot->ircnets != NULL)
bot_ircnet_destroy(bot, bot->ircnets->data);
line_split_free(bot->buffer);
g_free_not_null(bot->nick);
g_free(bot);
}
static GnomeVFSResult
remove_fake_node_by_uri (const GnomeVFSURI *uri)
{
FakeNode *file;
GNode *gnode;
file = get_fake_node_from_uri (uri);
if (!file) {
return GNOME_VFS_ERROR_INVALID_URI;
}
gnode = file->gnode;
g_node_unlink (gnode);
g_node_traverse (gnode,
G_PRE_ORDER,
G_TRAVERSE_ALL,
-1,
free_files_func,
NULL);
g_node_destroy (gnode);
print_tree (root, 0);
return GNOME_VFS_OK;
}
/**
* cleanup_menu_structure()
* @brief Cleanup for N-array tree
* @return 0 for success, -1 for error
*/
int cleanup_menu_structure()
{
if (root != NULL) {
g_node_destroy(root);
return (0);
}
return (-1);
}
void xml_free_tree(GNode *node)
{
cm_return_if_fail(node != NULL);
g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, xml_free_func,
NULL);
g_node_destroy(node);
}
/* apply the observation update to the belief state
* limiting the application to <radius> distance to edge <e>
*/
void state_observation_update (dijk_graph_t *dg, dijk_edge_t *e, int radius, navlcm_feature_list_t *f, GQueue *path, double *variance)
{
if (!e || !e->start)
return;
// convert to dual tree
GNode *tr = dijk_to_tree (e->start, radius);
// apply observation update to the tree
g_node_traverse (tr, G_PRE_ORDER, G_TRAVERSE_ALL, -1, state_observation_cb, f);
// compute variance across tree
*variance = .0;
g_node_traverse (tr, G_PRE_ORDER, G_TRAVERSE_ALL, -1, state_compute_variance_cb, variance);
*variance /= radius;
// destroy tree
g_node_destroy (tr);
// set to zero for all nodes out of the tree
for (GList *iter=g_queue_peek_head_link(dg->nodes);iter;iter=iter->next) {
dijk_node_t *nd = (dijk_node_t*)iter->data;
if (nd->timestamp != f->utime) {
nd->pdf0 = .0;
nd->pdf1 = .0;
}
}
// hack: set to zero for all nodes out of the path
for (GList *iter=g_queue_peek_head_link(dg->nodes);iter;iter=iter->next) {
dijk_node_t *nd = (dijk_node_t*)iter->data;
if (!path) continue;
gboolean on_path = FALSE;
for (GList *eiter=g_queue_peek_head_link (path);eiter;eiter=eiter->next) {
dijk_edge_t *e = (dijk_edge_t*)eiter->data;
if (e->start == nd || e->end == nd) {
on_path = TRUE;
}
}
if (!on_path) {
// nd->pdf0 = .0;
// nd->pdf1 = .0;
}
}
// normalize
double t = state_sum (dg);
if (t > 1E-6) {
for (GList *iter=g_queue_peek_head_link(dg->nodes);iter;iter=iter->next) {
dijk_node_t *nd = (dijk_node_t*)iter->data;
nd->pdf1 /= t;
}
}
}
void
glade_model_data_tree_free (GNode * node)
{
if (node)
{
g_node_traverse (node, G_IN_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) model_data_traverse_free, NULL);
g_node_destroy (node);
}
}
static void
dir_target_free (DirTarget *node)
{
DirTargetData *target = DIR_TARGET_DATA (node);
g_free (target->base.name);
g_slice_free (DirTargetData, target);
g_node_destroy (node);
}
// remove the whole sub tree under parent, parent is excluded
static void se_delete_subtree( GNode *parent )
{
g_assert( parent );
GNode *np = g_node_first_child( parent );
while ( np ) {
g_node_unlink( np );
g_node_destroy( np );
np = g_node_first_child( parent );
}
}
static void
dir_source_free (DirSource *node)
{
DirSourceData *source = DIR_SOURCE_DATA (node);
g_object_unref (source->base.file);
g_slice_free (DirSourceData, source);
g_node_destroy (node);
}
static void
dir_group_free (DirGroup *node)
{
DirGroupData *group = (DirGroupData *)node->data;
if (group->base.directory) g_object_unref (group->base.directory);
g_slice_free (DirGroupData, group);
g_node_destroy (node);
}
void g_node_safe_destroy(GNode * node)
{
//printf("Destroying node\n");
prong_assert(node != NULL);
g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, (GNodeTraverseFunc) free_job_node, NULL);
// Free nodes themselves
g_node_destroy(node);
//printf("Finished destroying node\n");
}
/*
Free a previously allocated tree
*/
int vat_free(GNode **tree)
{
if (*tree != NULL)
{
g_node_traverse(*tree, G_IN_ORDER, G_TRAVERSE_ALL, -1, free_vse, NULL);
g_node_destroy(*tree);
*tree = NULL;
}
return 0;
}
/**
* as_node_unref:
* @node: a #AsNode.
*
* Deallocates all notes in the tree.
*
* Since: 0.1.0
**/
void
as_node_unref (AsNode *node)
{
g_node_traverse (node,
G_PRE_ORDER,
G_TRAVERSE_ALL,
-1,
as_node_destroy_node_cb,
NULL);
g_node_destroy (node);
}
void
url_router_free (UrlRouter *router)
{
g_node_traverse(router,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
url_node_data_free_func,
NULL);
g_node_destroy(router);
}
static void
mount_node_free (GNode *node)
{
g_node_traverse (node,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
mount_info_free,
NULL);
g_node_destroy (node);
}
void
ph_stats_free(ph_stats_t *ps)
{
if (ps->stats_tree) {
g_node_traverse(ps->stats_tree, G_IN_ORDER,
G_TRAVERSE_ALL, -1,
stat_node_free, NULL);
g_node_destroy(ps->stats_tree);
}
g_free(ps);
}
static inline void
clutter_score_clear (ClutterScore *score)
{
ClutterScorePrivate *priv = score->priv;
g_node_traverse (priv->root,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
destroy_entry, NULL);
g_node_destroy (priv->root);
}
void
cleanup(GNode *root_node)
{
if (root_node == NULL) {
return;
}
g_node_traverse(root_node,
G_IN_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)cleanup_func,
(gpointer)NULL);
g_node_destroy(root_node);
}
static void reconstruct_bookmark_tree ()
{
GtkTreeIter iter;
new_bm_root = g_node_new (NULL);
if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(editor->store), &iter))
return;
/* fprintf (stderr, "Reconstruct root\n"); */
do {
_reconstruct_bookmark_tree (new_bm_root, &iter);
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(editor->store), &iter));
g_node_destroy (bookmark_root);
bookmark_root = new_bm_root;
}
static void
ltable_destroy(LTable* ltable)
{
if (ltable->tree != NULL)
{
g_node_traverse(ltable->tree, G_POST_ORDER, G_TRAVERSE_ALL, -1,
destroy_func, NULL);
g_node_destroy(ltable->tree);
}
g_ptr_array_free(ltable->listeners, TRUE);
g_slist_free(ltable->removed_indices);
g_free(ltable);
}
/**
* ticalcs_dirlist_destroy:
* @tree: the tree to destroy.
*
* Destroy the whole tree create by #ticalcs_calc_get_dirlist.
*
* Return value: none.
**/
TIEXPORT3 void TICALL ticalcs_dirlist_destroy(GNode** tree)
{
if (tree != NULL && *tree != NULL)
{
TreeInfo *ti;
if ((*tree)->children != NULL)
{
g_node_traverse(*tree, G_IN_ORDER, G_TRAVERSE_LEAVES, -1, free_varentry, NULL);
}
ti = (TreeInfo *)((*tree)->data);
g_free(ti);
g_node_destroy(*tree);
*tree = NULL;
}
}
void
glade_model_data_remove_column (GNode * node, gint nth)
{
GNode *row, *item;
GladeModelData *data;
g_return_if_fail (node != NULL);
for (row = node->children; row; row = row->next)
{
g_return_if_fail (nth >= 0 && nth < g_node_n_children (row));
item = g_node_nth_child (row, nth);
data = item->data;
glade_model_data_free (data);
g_node_destroy (item);
}
}
