void test_traversal(void)
{
FILENODE *node[5];
FILENODE *current_node;
GtkTreeIter iter;
int i = 0;
init_file_list();
node[0] = append_file("file1", "schema", "table", "geom_column", "-1", 'c', &iter);
CU_ASSERT_PTR_NOT_NULL(node[0]);
node[1] = append_file("file2", "schema", "table", "geom_column", "-1", 'c', &iter);
CU_ASSERT_PTR_NOT_NULL(node[1]);
node[2] = append_file("file3", "schema", "table", "geom_column", "-1", 'c', &iter);
CU_ASSERT_PTR_NOT_NULL(node[2]);
node[3] = append_file("file4", "schema", "table", "geom_column", "-1", 'c', &iter);
CU_ASSERT_PTR_NOT_NULL(node[3]);
node[4] = append_file("file5", "schema", "table", "geom_column", "-1", 'c', &iter);
CU_ASSERT_PTR_NOT_NULL(node[4]);
current_node = get_next_node(NULL);
CU_ASSERT_PTR_NOT_NULL(current_node);
while (current_node != NULL)
{
CU_ASSERT_NOT_EQUAL(i, 5);
CU_ASSERT_PTR_EQUAL(current_node, node[i]);
current_node = get_next_node(current_node);
i++;
}
}
void follow_tail(void)
{
--snake_length_current;
//is tail a neighbor of next?
if (neighbors(corners[tail],corners[get_next_node(tail)]))
{
tail = get_next_node(tail);
}
//find which axis tail and next have in common
else
{
if (corners[tail].x == corners[get_next_node(tail)].x)
{
//These points have the same X, so make adjustment to the Y
if ((corners[tail].y - corners[get_next_node(tail)].y) < 0) corners[tail].y += 1;
else corners[tail].y -= 1;
}
else
{
//These points have the same Y, so make adjustment to the X
if ((corners[tail].x - corners[get_next_node(tail)].x) < 0) corners[tail].x += 1;
else corners[tail].x -= 1;
}
}
}
void
Ndb_cluster_connection_impl::do_test()
{
Ndb_cluster_connection_node_iter iter;
int n= no_db_nodes()+5;
Uint32 *nodes= new Uint32[n+1];
for (int g= 0; g < n; g++)
{
for (int h= 0; h < n; h++)
{
Uint32 id;
Ndb_cluster_connection_node_iter iter2;
{
for (int j= 0; j < g; j++)
{
nodes[j]= get_next_node(iter2);
}
}
for (int i= 0; i < n; i++)
{
init_get_next_node(iter);
fprintf(stderr, "%d dead:(", g);
id= 0;
while (id == 0)
{
if ((id= get_next_node(iter)) == 0)
break;
for (int j= 0; j < g; j++)
{
if (nodes[j] == id)
{
fprintf(stderr, " %d", id);
id= 0;
break;
}
}
}
fprintf(stderr, ")");
if (id == 0)
{
break;
}
fprintf(stderr, " %d\n", id);
}
fprintf(stderr, "\n");
}
}
delete [] nodes;
}
PurpleBlistNode *purple_blist_node_next(PurpleBlistNode *node, gboolean offline)
{
PurpleBlistNode *ret = node;
if (offline)
return get_next_node(ret, TRUE);
do
{
ret = get_next_node(ret, TRUE);
} while (ret && PURPLE_IS_BUDDY(ret) &&
!purple_account_is_connected(purple_buddy_get_account((PurpleBuddy *)ret)));
return ret;
}
static HRESULT WINAPI xmlnodelist_get_length(
IXMLDOMNodeList* iface,
long* listLength)
{
xmlNodePtr curr, tmp;
xmlNodePtr *top_level_node = NULL;
long nodeCount = 0;
HRESULT r;
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
TRACE("%p\n", This);
if (This->node == NULL) {
*listLength = 0;
return S_OK;
}
if(This->enum_children)
{
tmp = curr;
top_level_node = &tmp;
}
for(curr = This->node; curr; curr = get_next_node(&This->xinfo, curr, top_level_node))
{
r = xslt_next_match( &This->xinfo, &curr, top_level_node );
if(FAILED(r) || !curr) break;
nodeCount++;
}
*listLength = nodeCount;
return S_OK;
}
static HRESULT WINAPI xmlnodelist_nextNode(
IXMLDOMNodeList* iface,
IXMLDOMNode** nextItem)
{
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
HRESULT r;
xmlNodePtr *top_level_node = NULL;
TRACE("%p %p\n", This, nextItem );
*nextItem = NULL;
if(This->enum_children)
top_level_node = &This->top_level_node;
r = xslt_next_match( &This->xinfo, &This->current, top_level_node );
if (FAILED(r) )
return r;
if (!This->current)
return S_FALSE;
*nextItem = create_node( This->current );
This->current = get_next_node(&This->xinfo, This->current, top_level_node);
return S_OK;
}
static HRESULT xslt_next_match( struct xslt_info *info, xmlNodePtr *node, xmlNodePtr *top_level_node )
{
if (!info->ctxt)
return S_FALSE;
/* make sure that the current element matches the pattern */
while ( *node )
{
int r;
r = xsltTestCompMatchList( info->ctxt, *node, info->pattern );
if ( 1 == r )
{
TRACE("Matched %p (%s)\n", *node, (*node)->name );
return S_OK;
}
if (r != 0)
{
ERR("Pattern match failed\n");
return E_FAIL;
}
*node = get_next_node(info, *node, top_level_node);
}
return S_OK;
}
void switch_lpm_trie_insert(switch_lpm_trie_t *trie,
const char *prefix,
int prefix_length,
const value_t value) {
node_t *current_node = trie->root;
byte_t byte;
unsigned short prefix_key;
while (prefix_length >= 8) {
byte = (byte_t)*prefix;
node_t *node = get_next_node(current_node, byte);
if (!node) {
allocate_node(&node);
node->parent = current_node;
node->child_id = byte;
set_next_node(current_node, byte, node);
current_node->branch_num++;
}
prefix++;
prefix_length -= 8;
current_node = node;
}
if (prefix_length == 0)
prefix_key = 0;
else
prefix_key = get_prefix_key((unsigned)prefix_length, (byte_t)*prefix);
if (!insert_prefix(current_node, prefix_key, value)) current_node->pref_num++;
trie->num_entries++;
}
int g2_breadth_first_road_solver_class::path_solve(g1_team_type team, g1_road_object_class * start, g1_road_object_class * dest,
g1_path_object_class * * path, w32 stack_size)
{
g1_road_object_class * node;
i4_float len; //actually we now use exspected time
clear_heap();
clear_solve();
if (!start || !dest)
{
return i4_F;
}
add_node(start, 0, 0);
link_manager * lman=g2_link_man();
len=0;
w32 starttime=(w32)g2_act_man()->daytime;
while (get_next_node(node, len))
{
//g1_road_object_class *c =0;
for (int i=0; i<node->total_links(G1_ALLY); i++) //ally means outgoing
{
g2_link * l=lman->get_link(node->get_link_id(G1_ALLY,i));
i4_float extime=l->quratio(starttime,len);
//i4_float extime=l->get_length()/l->get_freespeed();
add_node((g1_road_object_class *)node->get_link(G1_ALLY,i), node,
len + extime);
//else we skip.
}
}
w32 points=0;
if (dest->ref==0)
{
return 0;
}
// count nodes
node = dest;
points = 0;
while (node!=start&&points<(stack_size))
{
/*point[points*2+0] = i4_float(graph->critical[node].x)+0.5f;
point[points*2+1] = i4_float(graph->critical[node].y)+0.5f;
points++;
node = solve_graph[node].ref;*/
path[points++]=node;
node=node->ref;
}
path[points++]=start; //it seems paths need this entry to work correctly
//point[points*2+0] = i4_float(graph->critical[start_node].x)+0.5f;
//point[points*2+1] = i4_float(graph->critical[start_node].y)+0.5f;
//points++;
return points;
}
MatchErrorCode
MatchTable::modify_entry(
entry_handle_t handle, const ActionFn *action_fn, ActionData action_data
)
{
WriteLock lock = lock_write();
ActionFnEntry action_fn_entry(action_fn, std::move(action_data));
const ControlFlowNode *next_node = get_next_node(action_fn->get_id());
return match_unit->modify_entry(
handle, ActionEntry(std::move(action_fn_entry), next_node)
);
}
uint8_t collision(void)
{
uint8_t lower = 0;
uint8_t upper = 0;
uint8_t testpoint = 1;
uint8_t i=tail;
uint8_t nextNode = get_next_node(i);;
//Check to see if we hit part of the snake
//traverse all nodes from tail forward
for (int8_t count=get_node_list_length(tail,head)-3; count>0; count--)
//while (nextNode<head)
//( check head-3 because you can't run into a segment any close than that to the head)
{
//check to see if head's x or y are shared with the current point
if ((corners[head].x == corners[i].x) && (corners[i].x == corners[nextNode].x))
{
//which point is the higher number?
if (corners[i].y < corners[nextNode].y) {lower = corners[i].y; upper = corners[nextNode].y;}
else {lower = corners[nextNode].y; upper = corners[i].y;}
testpoint = corners[head].y;
}
else if ((corners[head].y == corners[i].y) && (corners[i].y == corners[nextNode].y))
{
//which point is the higher number?
if (corners[i].x < corners[nextNode].x) {lower = corners[i].x; upper = corners[nextNode].x;}
else {lower = corners[nextNode].x; upper = corners[i].x;}
testpoint = corners[head].x;
}
else continue;
//Now check to see if head is a point between this node and the next
if ((lower<=testpoint) && (testpoint<= upper)) return 1;
i = nextNode;
nextNode = get_next_node(i);
}
return 0;
}
static PurpleBlistNode *get_next_node(PurpleBlistNode *node, gboolean godeep)
{
if (node == NULL)
return NULL;
if (godeep && node->child)
return node->child;
if (node->next)
return node->next;
return get_next_node(node->parent, FALSE);
}
MatchErrorCode
MatchTable::set_default_action(
const ActionFn *action_fn, ActionData action_data
)
{
ActionFnEntry action_fn_entry(action_fn, std::move(action_data));
const ControlFlowNode *next_node = get_next_node(action_fn->get_id());
WriteLock lock = lock_write();
default_entry = ActionEntry(std::move(action_fn_entry), next_node);
return MatchErrorCode::SUCCESS;
}
idxint ECOS_BB_solve(ecos_bb_pwork* prob) {
idxint curr_node_idx = 0;
#if MI_PRINTLEVEL > 0
if (prob->stgs->verbose){
PRINTTEXT("Iter\tLower Bound\tUpper Bound\tGap\n");
PRINTTEXT("================================================\n");
}
#endif
/* Initialize to root node and execute steps 1 on slide 6 */
/* of http://stanford.edu/class/ee364b/lectures/bb_slides.pdf*/
prob->iter = 0;
initialize_root(prob);
/*print_node(prob, curr_node_idx);*/
get_bounds(curr_node_idx, prob);
prob->global_L = prob->nodes[curr_node_idx].L;
prob->global_U = prob->nodes[curr_node_idx].U;
while ( should_continue(prob, curr_node_idx) ){
#if MI_PRINTLEVEL > 0
if (prob->stgs->verbose){ print_progress(prob); }
#endif
++(prob->iter);
/* Step 2*/
/* Branch replaces nodes[curr_node_idx] with leftNode*/
/* and nodes[prob->iter] with rightNode */
branch(curr_node_idx, prob);
/* Step 3*/
get_bounds(curr_node_idx, prob);
get_bounds(prob->iter, prob);
/* Step 4*/
prob->global_L = get_global_L(prob);
curr_node_idx = get_next_node(prob);
}
load_solution(prob);
#if MI_PRINTLEVEL > 0
if (prob->stgs->verbose){ print_progress(prob); }
#endif
return get_ret_code(prob);
}
MatchErrorCode
MatchTableIndirect::modify_member(
mbr_hdl_t mbr, const ActionFn *action_fn, ActionData action_data
)
{
ActionFnEntry action_fn_entry(action_fn, std::move(action_data));
const ControlFlowNode *next_node = get_next_node(action_fn->get_id());
WriteLock lock = lock_write();
if(!is_valid_mbr(mbr)) return MatchErrorCode::INVALID_MBR_HANDLE;
action_entries[mbr] = ActionEntry(std::move(action_fn_entry), next_node);
return MatchErrorCode::SUCCESS;
}
/* Find a direct sub-node of a given parent node. */
int grub_fdt_find_subnode (const void *fdt, unsigned int parentoffset,
const char *name)
{
grub_uint32_t *token, *end;
char *node_name;
if (parentoffset & 0x3)
return -1;
token = (void *) ((grub_addr_t) fdt + grub_fdt_get_off_dt_struct(fdt)
+ parentoffset);
end = (void *) struct_end (fdt);
if ((token >= end) || (grub_be_to_cpu32(*token) != FDT_BEGIN_NODE))
return -1;
SKIP_NODE_NAME(node_name, token, end);
while (token < end)
{
switch (grub_be_to_cpu32(*token))
{
case FDT_BEGIN_NODE:
node_name = (char *) (token + 1);
if (node_name + grub_strlen (name) >= (char *) end)
return -1;
if (!grub_strcmp (node_name, name))
return (int) ((grub_addr_t) token - (grub_addr_t) fdt
- grub_fdt_get_off_dt_struct (fdt));
token = get_next_node (fdt, node_name);
if (!token)
return -1;
break;
case FDT_PROP:
/* Skip property token and following data (len, nameoff and property
value). */
if (token >= end - 1)
return -1;
token += prop_entry_size(grub_be_to_cpu32(*(token + 1)))
/ sizeof(*token);
break;
case FDT_NOP:
token++;
break;
default:
return -1;
}
}
return -1;
}
MatchErrorCode
MatchTable::add_entry(
const std::vector<MatchKeyParam> &match_key,
const ActionFn *action_fn, ActionData action_data, // move it
entry_handle_t *handle, int priority
)
{
ActionFnEntry action_fn_entry(action_fn, std::move(action_data));
const ControlFlowNode *next_node = get_next_node(action_fn->get_id());
WriteLock lock = lock_write();
return match_unit->add_entry(
match_key,
ActionEntry(std::move(action_fn_entry), next_node),
handle, priority
);
}
static void handle_init_event(node_state *ns, tw_bf *b, node_msg *m, tw_lp *lp) {
int dest_id;
node_msg m_remote;
m_remote.node_event_type = PING;
m_remote.src = lp->gid;
ns->start_ts = tw_now(lp);
ns->last_ts = ns->start_ts;
dest_id = get_next_node(lp->gid);
if (dest_id == -1) return;
int dim_lens[3] = {10, 10, 10};
model_net_torus_get_dim_id(dest_id, 3, dim_lens, ns->dest_dim_id); //dim length hard-coded for now
model_net_event(net_id, "ping", dest_id, payload_sz, 0.0, sizeof(node_msg),
(const void*)&m_remote, 0, NULL, lp);
ns->msg_sent_count++;
}
MatchErrorCode
MatchTableIndirect::add_member(
const ActionFn *action_fn, ActionData action_data,
mbr_hdl_t *mbr
)
{
ActionFnEntry action_fn_entry(action_fn, std::move(action_data));
const ControlFlowNode *next_node = get_next_node(action_fn->get_id());
WriteLock lock = lock_write();
if(mbr_handles.get_handle(mbr)) return MatchErrorCode::ERROR;
entries_insert(*mbr, ActionEntry(std::move(action_fn_entry), next_node));
num_members++;
return MatchErrorCode::SUCCESS;
}
bool switch_lpm_trie_delete(switch_lpm_trie_t *trie,
const char *prefix,
int prefix_length) {
node_t *current_node = trie->root;
byte_t byte;
unsigned short prefix_key;
value_t *pdata = NULL;
while (prefix_length >= 8) {
byte = (byte_t)*prefix;
node_t *node = get_next_node(current_node, byte);
if (!node) return NULL;
prefix++;
prefix_length -= 8;
current_node = node;
}
if (prefix_length == 0)
prefix_key = 0;
else
prefix_key = get_prefix_key((unsigned)prefix_length, (byte_t)*prefix);
pdata = get_prefix_ptr(current_node, prefix_key);
if (!pdata) return false;
if (trie->release_memory) {
assert(delete_prefix(current_node, prefix_key) == 1);
current_node->pref_num--;
while (current_node->pref_num == 0 && current_node->branch_num == 0) {
node_t *tmp = current_node;
current_node = current_node->parent;
if (!current_node) break;
assert(delete_branch(current_node, tmp->child_id) == 1);
switch_free(tmp);
current_node->branch_num--;
}
}
trie->num_entries--;
return true;
}
static grub_uint32_t *get_next_node (const void *fdt, char *node_name)
{
grub_uint32_t *end = (void *) struct_end (fdt);
grub_uint32_t *token;
if (node_name >= (char *) end)
return NULL;
while (*node_name++)
{
if (node_name >= (char *) end)
return NULL;
}
token = (grub_uint32_t *) ALIGN_UP ((grub_addr_t) node_name, 4);
while (token < end)
{
switch (grub_be_to_cpu32(*token))
{
case FDT_BEGIN_NODE:
token = get_next_node (fdt, (char *) (token + 1));
if (!token)
return NULL;
break;
case FDT_END_NODE:
token++;
if (token >= end)
return NULL;
return token;
case FDT_PROP:
/* Skip property token and following data (len, nameoff and property
value). */
token += prop_entry_size(grub_be_to_cpu32(*(token + 1)))
/ sizeof(*token);
break;
case FDT_NOP:
token++;
break;
default:
return NULL;
}
}
return NULL;
}
void move_head(uint8_t new_dir)
{
if (new_dir)
{
//Copy head to new position
head = get_next_node(head); //increment head
corners[head].x = corners[get_previous_node(head)].x;
corners[head].y = corners[get_previous_node(head)].y;
change_direction(); //change direction
}
//Have we left the game board?
if ((corners[head].x == 0) && (dirX == -1)) { game_over(); return; }
if ((corners[head].y == 0) && (dirY == -1)) { game_over(); return; }
if ((corners[head].x == GAMEBOARD_X-1) && (dirX == 1)) { game_over(); return; }
if ((corners[head].y == GAMEBOARD_Y-1) && (dirY == 1)) { game_over(); return; }
corners[head].x += dirX;
corners[head].y += dirY;
++snake_length_current;
}
Uint32
Ndb_cluster_connection_impl::get_next_alive_node(Ndb_cluster_connection_node_iter &iter)
{
Uint32 id;
TransporterFacade *tp = m_impl.m_transporter_facade;
if (tp == 0 || tp->ownId() == 0)
return 0;
while ((id = get_next_node(iter)))
{
tp->lock_mutex();
if (tp->get_node_alive(id) != 0)
{
tp->unlock_mutex();
return id;
}
tp->unlock_mutex();
}
return 0;
}
bool switch_lpm_trie_lookup(const switch_lpm_trie_t *trie,
const char *key,
value_t *pvalue) {
const node_t *current_node = trie->root;
byte_t byte;
size_t key_width = trie->key_width_bytes;
value_t *pdata = NULL;
unsigned short prefix_key;
unsigned i;
bool found = false;
while (current_node) {
pdata = get_prefix_ptr(current_node, 0);
if (pdata) {
*pvalue = *pdata;
found = true;
}
if (key_width > 0) {
byte = (byte_t)*key;
for (i = 7; i > 0; i--) {
prefix_key = get_prefix_key((unsigned)i, byte);
pdata = get_prefix_ptr(current_node, prefix_key);
if (pdata) {
*pvalue = *pdata;
found = true;
break;
}
}
current_node = get_next_node(current_node, byte);
key++;
key_width--;
} else {
break;
}
}
return found;
}
static HRESULT WINAPI xmlnodelist_get_item(
IXMLDOMNodeList* iface,
long index,
IXMLDOMNode** listItem)
{
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
xmlNodePtr curr, tmp;
xmlNodePtr *top_level_node = NULL;
long nodeIndex = 0;
HRESULT r;
TRACE("%p %ld\n", This, index);
*listItem = NULL;
if (index < 0)
return S_FALSE;
curr = This->node;
if(This->enum_children)
{
tmp = curr;
top_level_node = &tmp;
}
while(curr)
{
r = xslt_next_match( &This->xinfo, &curr, top_level_node);
if(FAILED(r) || !curr) return S_FALSE;
if(nodeIndex++ == index) break;
curr = get_next_node(&This->xinfo, curr, top_level_node);
}
if(!curr) return S_FALSE;
*listItem = create_node( curr );
return S_OK;
}
bool switch_lpm_trie_has_prefix(const switch_lpm_trie_t *trie,
const char *prefix,
int prefix_length) {
node_t *current_node = trie->root;
byte_t byte;
unsigned short prefix_key;
while (prefix_length >= 8) {
byte = (byte_t)*prefix;
node_t *node = get_next_node(current_node, byte);
if (!node) return false;
prefix++;
prefix_length -= 8;
current_node = node;
}
if (prefix_length == 0)
prefix_key = 0;
else
prefix_key = get_prefix_key((unsigned)prefix_length, (byte_t)*prefix);
return (get_prefix_ptr(current_node, prefix_key) != NULL);
}
main(int argc ,char *argv[])
{
int i;
/*checking for creation and printing the tree ---Working*/
node *tree ;
tree=create_tree();
read_ssf_from_file(tree, argv[1]);
print_tree(tree);
printf("Checked read and print\n\n");
/*checking for get_nth_child ----Working*/
node *child = get_nth_child(tree, 2);
print_node_without_index(child);
printf("Checked get_nth_child\n\n");
/*checking for getchildren-----Working*/
list_of_nodes *l1;
l1=getchildren(tree);
printf("\n\nsize=%d\n", l1->size);
for (i=0; i< l1->size; i++)
{
print_attr_of_node(l1->l[i] );
printf("\n");
}
printf("Checked getchildren\n\n");
/*checking for getleaves----Working*/
list_of_nodes *l2;
l2=getleaves(tree);
printf("\n\nsize=%d\n", l2->size);
for (i=0; i< l2->size; i++)
{
print_attr_of_node(l2->l[i] );
printf("\n");
}
printf("Checked getleaves\n\n");
/*checking for getleaves_child---Working*/
list_of_nodes *l3;
l3=getleaves_child(l1->l[1]);
printf("\n\nsize=%d\n", l3->size);
for (i=0; i< l3->size; i++)
{
print_attr_of_node(l3->l[i] );
printf("\n");
}
printf("Checked getleaves_child\n\n");
/*checking for get_nodes---Working*/
list_of_nodes *l4;
l4=get_nodes(2,"NNS",tree);
printf("\n\nsize=%d\n",l4->size);
for (i=0; i< l4->size; i++)
{
print_attr_of_node(l4->l[i]);
printf("\n");
}
printf("Checked get_nodes\n\n");
/*checking for get_pattern---Working*/
list_of_nodes *l5;
l5=get_pattern(2,".*N.*",tree);
printf("\n\nsize=%d\n",l5->size);
for (i=0; i< l5->size; i++)
{
print_attr_of_node(l5->l[i]);
printf("\n");
}
printf("Checked get_pattern\n\n");
//checking for delete_node------Working
//printf("%d\n",delete_node(l5->l[1]));
//print_tree(tree);
//checking for count_leaf_nodes ----Working
printf("count of leaf nodes----%d\n\n", count_leaf_nodes(tree));
//checking for get_field(s) ----Working
char *str;
str=get_field(l5->l[1],1);
printf("%s\n",str);
str=get_fields(l5->l[1]);
printf("%s\n", str);
printf("Checked get_field and get_fields\n\n");
//checking for get_next_node and get_previos_node----Working
node *N;
N=get_next_node(l1->l[1]);
str=get_fields(N);
printf("%s\n", str);
N=get_previous_node(l1->l[1]);
str=get_fields(N);
printf("%s\n", str);
printf("Checked get_next_node & get_previous_node\n\n");
//checking for insert_node_position------Working
node *M;
M=create_node_with_attr("iiit","NNP","<loc=hyd>",NULL);
insert_node_into_position(tree,M,1);
print_tree(tree);
printf("Checked insert_node_position\n\n");
/*Checkin print_attr_of_or_node--------Working*/
print_attr_of_or_node(M->OR);
printf("\nChecked print_attr_of_or_node\n\n");
}
