void
glade_model_data_insert_column (GNode * node,
GType type, const gchar * column_name, 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));
data = glade_model_data_new (type, column_name);
item = g_node_new (data);
g_node_insert (row, nth, item);
}
}
/**
* Gets a flat collection of nodes, sorted by priority
**/
GNode*
get_transactions(GNode *config, boolean priority_mode)
{
d_dplog("commit2::get_transactions()");
if (config == NULL) {
return NULL;
}
gpointer gp = ((GNode*)config)->data;
GNode *trans_root = g_node_new(gp);
if (priority_mode) {
g_node_traverse(config,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)sort_func_priority,
(gpointer)trans_root);
//only do this if the root isn't empty
if (g_node_n_children(config) != 0) {
g_node_insert(trans_root,-1,config); //add what's left
}
//now need pass to handle extended priority system
g_node_traverse(trans_root,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)sort_func_priority_extended,
(gpointer)trans_root);
}
else {
g_node_traverse(config,
G_IN_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)sort_func_simple,
(gpointer)trans_root);
}
return trans_root;
}
static gint decrypt(MimeInfo *mimeinfo, PrivacySystem *system)
{
MimeInfo *decryptedinfo, *parentinfo;
gint childnumber;
cm_return_val_if_fail(system->decrypt != NULL, -1);
decryptedinfo = system->decrypt(mimeinfo);
if (decryptedinfo == NULL)
return -1;
parentinfo = procmime_mimeinfo_parent(mimeinfo);
childnumber = g_node_child_index(parentinfo->node, mimeinfo);
procmime_mimeinfo_free_all(&mimeinfo);
g_node_insert(parentinfo->node, childnumber, decryptedinfo->node);
return 0;
}
static void
g_node_test (void)
{
GNode *root;
GNode *node;
GNode *node_B;
GNode *node_D;
GNode *node_F;
GNode *node_G;
GNode *node_J;
guint i;
gchar *tstring;
failed = FALSE;
root = g_node_new (C2P ('A'));
TEST (NULL, g_node_depth (root) == 1 && g_node_max_height (root) == 1);
node_B = g_node_new (C2P ('B'));
g_node_append (root, node_B);
TEST (NULL, root->children == node_B);
g_node_append_data (node_B, C2P ('E'));
g_node_prepend_data (node_B, C2P ('C'));
node_D = g_node_new (C2P ('D'));
g_node_insert (node_B, 1, node_D);
node_F = g_node_new (C2P ('F'));
g_node_append (root, node_F);
TEST (NULL, root->children->next == node_F);
node_G = g_node_new (C2P ('G'));
g_node_append (node_F, node_G);
node_J = g_node_new (C2P ('J'));
g_node_prepend (node_G, node_J);
g_node_insert (node_G, 42, g_node_new (C2P ('K')));
g_node_insert_data (node_G, 0, C2P ('H'));
g_node_insert (node_G, 1, g_node_new (C2P ('I')));
TEST (NULL, g_node_depth (root) == 1);
TEST (NULL, g_node_max_height (root) == 4);
TEST (NULL, g_node_depth (node_G->children->next) == 4);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 11);
TEST (NULL, g_node_max_height (node_F) == 3);
TEST (NULL, g_node_n_children (node_G) == 4);
TEST (NULL, g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F);
TEST (NULL, g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL);
TEST (NULL, g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J);
for (i = 0; i < g_node_n_children (node_B); i++)
{
node = g_node_nth_child (node_B, i);
TEST (NULL, P2C (node->data) == ('C' + i));
}
for (i = 0; i < g_node_n_children (node_G); i++)
TEST (NULL, g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i);
/* we have built: A
* / \
* B F
* / | \ \
* C D E G
* / /\ \
* H I J K
*
* for in-order traversal, 'G' is considered to be the "left"
* child of 'F', which will cause 'F' to be the last node visited.
*/
tstring = NULL;
g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABCDEFGHIJK") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_POST_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "CDEBHIJKGFA") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "CBDEAHGIJKF") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFCDEGHIJK") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_LEAFS, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "CDEHIJK") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_NON_LEAFS, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFG") == 0);
g_free (tstring); tstring = NULL;
g_node_reverse_children (node_B);
g_node_reverse_children (node_G);
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFEDCGKJIH") == 0);
g_free (tstring); tstring = NULL;
g_node_append (node_D, g_node_new (C2P ('L')));
g_node_append (node_D, g_node_new (C2P ('M')));
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFEDCGLMKJIH") == 0);
g_free (tstring); tstring = NULL;
g_node_destroy (root);
/* allocation tests */
root = g_node_new (NULL);
node = root;
for (i = 0; i < 2048; i++)
{
g_node_append (node, g_node_new (NULL));
if ((i%5) == 4)
node = node->children->next;
}
TEST (NULL, g_node_max_height (root) > 100);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048);
g_node_destroy (root);
if (failed)
exit(1);
}
gboolean
sort_func(GNode *node, gpointer data, boolean priority_mode)
{
struct VyattaNode *gp = (struct VyattaNode *) node->data;
struct Data *d = &(gp->_data);
GNode *root_node = (GNode*)data;
d_dplog("commit2::sort_func(): %s, node count: %d",
(d->_name ? d->_name : "[n/a]"), g_node_n_children(root_node));
//change action state of node according to enclosing behavior
/* XXX this is ugly. originally the condition for the if is the following:
* (c1 && c2 || (c3 || c4) && c5)
*
* this causes compiler warning for mixing && and || without (). the
* previous warning removal attempt changed the condition to the
* following:
* ((c1 && c2) || (c3 || (c4 && c5)))
*
* which was incorrect (c3 and c4 should be at the same "level") and
* therefore was reverted.
*
* now changing the condition to the following to avoid compiler
* warning:
* ((c1 && c2) || ((c3 || c4) && c5))
*
* note that since the current goal is simply cleanup, no attempt is
* made to understand the logic here, and the change is purely based
* on operator precendence to maintain the original logic.
*
* XXX now removing deactivate-handling code, which involves c2.
*
* note that c2 is (d->_disable_op != K_NO_DISABLE_OP), which means
* the node is "deactivated" (in working or active config or both).
* this in turn means that the (c1 && c2) part of the logic can only
* be true if the node is deactivated.
*
* however, since activate/deactivate has not actually been exposed,
* this means that in actual usage the (c1 && c2) part is never true.
* therefore, we can simply remove the whole part, and the logic
* becomes:
* ((c3 || c4) && c5)
*/
NODE_OPERATION op = d->_operation;
if (((/* c3 */ IS_SET_OR_CREATE(op)) || (/* c4 */ IS_DELETE(op)))
&& (/* c5 */ IS_NOOP(((struct VyattaNode*)
(node->parent->data))->_data._operation))) {
//first check if there is enclosing behavior
boolean enclosing = FALSE;
GNode *n = node;
while (TRUE) {
n = n->parent;
vtw_def def = ((struct VyattaNode*)(n->data))->_config._def;
if (def.actions[end_act].vtw_list_head
|| def.actions[begin_act].vtw_list_head) {
enclosing = TRUE;
break;
}
if (G_NODE_IS_ROOT(n) == TRUE) {
break;
}
}
//walk back up and flip operations until enclosing behavior
if (enclosing == TRUE) {
GNode *n = node;
while (TRUE) {
n = n->parent;
vtw_def def = ((struct VyattaNode*)(n->data))->_config._def;
if (((struct VyattaNode*)(n->data))->_data._operation == K_NO_OP) {
/* XXX this is ugly. _operation is intended to be a bitmap, in which
* case it doesn't make sense to make it an enum type (should
* just be, e.g., int). this causes g++ to (rightly) complain.
* work around it for now to avoid impacting other code since
* the current goal is simply cleanup.
*/
int op = ((struct VyattaNode*)(n->data))->_data._operation;
op |= K_ACTIVE_OP;
((struct VyattaNode*)(n->data))->_data._operation
= (NODE_OPERATION) op;
}
if (def.actions[end_act].vtw_list_head
|| def.actions[begin_act].vtw_list_head) {
break;
}
if (G_NODE_IS_ROOT(n) == TRUE) {
break;
}
}
}
}
if (priority_mode) {
int gprio = gp->_config._priority;
if (gprio < LOWEST_PRIORITY) {
// only if priority is specified.
//unlink from original tree
g_node_unlink(node);
GNode *new_node = g_node_copy(node);
GNode *sibling = root_node->children;
//now iterate through siblings of root_node and compare priority
while (sibling
&& gprio > ((struct VyattaNode*)(sibling->data))
->_config._priority) {
sibling = sibling->next;
if (!sibling
|| gprio < ((struct VyattaNode*)(sibling->data))
->_config._priority) {
// XXX isn't this redundant??? just cleaning up so not changing it
break;
}
}
d_dplog("commit2::sort_func(): inserting %s into transaction, "
"priority: %d BEFORE %d", d->_name, gprio,
(sibling
? ((struct VyattaNode*)(sibling->data))->_config._priority
: LOWEST_PRIORITY));
g_node_insert_before(root_node,sibling,new_node);
}
}
else {
if (g_node_depth(node) == 2) {
d_dplog("commit2::sort_func(): insert %s into transaction", d->_name);
GNode *new_node = g_node_copy(node);
g_node_insert(root_node,-1,new_node); //make a flat structure for now
}
}
return FALSE;
}