static int explorer_cb(Quark *q, int etype, void *udata)
{
ExplorerUI *eui = (ExplorerUI *) udata;
TreeItem *item = quark_get_udata(q);
TreeItem *parent_item;
switch (etype) {
case QUARK_ETYPE_DELETE:
TreeDeleteItem(eui->tree, item);
break;
case QUARK_ETYPE_MODIFY:
init_item(eui, item, q);
break;
case QUARK_ETYPE_NEW:
create_hook(q, eui, NULL);
break;
case QUARK_ETYPE_MOVE:
explorer_save_quark_state(eui);
TreeDeleteItem(eui->tree, item);
parent_item = quark_get_udata(quark_parent_get(q));
item = TreeInsertItem(eui->tree, parent_item, q, quark_get_id(q));
init_item(eui, item, q);
quark_set_udata(q, item);
storage_traverse(quark_get_children(q), create_children_hook, eui);
explorer_restore_quark_state(eui);
break;
}
TreeRefresh(eui->tree);
return TRUE;
}
int main()
{
Item items[9];
int last = 0;
int day;
int index;
init_item(items + last++, "+5 Dexterity Vest", 10, 20);
init_item(items + last++, "Aged Brie", 2, 0);
init_item(items + last++, "Elixir of the Mongoose", 5, 7);
init_item(items + last++, "Sulfuras, Hand of Ragnaros", 0, 80);
init_item(items + last++, "Sulfuras, Hand of Ragnaros", -1, 80);
init_item(items + last++, "Backstage passes to a TAFKAL80ETC concert", 15, 20);
init_item(items + last++, "Backstage passes to a TAFKAL80ETC concert", 10, 49);
init_item(items + last++, "Backstage passes to a TAFKAL80ETC concert", 5, 49);
// this Conjured item doesn't yet work properly
init_item(items + last++, "Conjured Mana Cake", 3, 6);
puts("OMGHAI!");
for (day = 0; day <= 30; day++)
{
printf("-------- day %d --------\n", day);
printf("name, sellIn, quality\n");
for(index = 0; index < last; index++) {
print_item(items + index);
}
printf("\n");
update_quality(items, last);
}
return 0;
}
TEST(List, Find)
{
int idx;
Item *head = 0;
Item *item = 0;
int num = 10;
Item items[num];
// Initialise each item
for (int i = 0; i < num; i++)
{
init_item(& items[i], i);
}
// create a randomised table of indexes
int block[num];
rand_array(block, num);
// add our items randomly to sorted list
for (int i = 0; i < num; i++)
{
int idx = block[i];
item = & items[idx];
item_add_sorted(& head, item, 0);
}
// find first item
idx = 0;
item = item_find(& head, & items[idx], 0);
EXPECT_EQ(item, & items[idx]);
// find last item
idx = num-1;
item = item_find(& head, & items[idx], 0);
EXPECT_EQ(item, & items[idx]);
// find middle item
idx = num / 2;
item = item_find(& head, & items[idx], 0);
EXPECT_EQ(item, & items[idx]);
// try to find non-existent item
Item wrong;
init_item(& wrong, -5);
item = item_find(& head, & wrong, 0);
EXPECT_EQ(0, item);
}
void frontier_push(board_node *node) {
list *item = init_item(node);
get_head();
while(frontier->next != NULL) {
board_node *l_node = frontier->node;
if (l_node->cost < node->cost) {
break;
}
frontier = frontier->next;
}
item->next = frontier;
item->prev = frontier->prev;
if (frontier->prev != NULL) {
frontier->prev->next = item;
}
frontier->prev = item;
frontier = item;
list_rewind(frontier);
}
void
phase1_map(GList *maps, FILE *out_ways, FILE *out_nodes)
{
struct map_rect *mr;
struct item *item;
int count;
struct coord ca[phase1_coord_max];
struct attr attr;
struct item_bin *item_bin;
while (maps) {
mr=map_rect_new(maps->data, NULL);
while ((item = map_rect_get_item(mr))) {
count=item_coord_get(item, ca, item->type < type_line ? 1: phase1_coord_max);
item_bin=init_item(item->type);
item_bin_add_coord(item_bin, ca, count);
while (item_attr_get(item, attr_any, &attr)) {
if (attr.type >= attr_type_string_begin && attr.type <= attr_type_string_end) {
attr.u.str=map_convert_string(maps->data, attr.u.str);
if (attr.u.str) {
item_bin_add_attr(item_bin, &attr);
map_convert_free(attr.u.str);
}
} else
item_bin_add_attr(item_bin, &attr);
}
if (item->type >= type_line)
item_bin_write(item_bin, out_ways);
else
item_bin_write(item_bin, out_nodes);
}
map_rect_destroy(mr);
maps=g_list_next(maps);
}
}
static item_t* fill_get_response_header(char *key ,intptr_t bytes){
char *s=(char *)alloc_mem(pool,20);
sprintf(s,"%ld",bytes);
intptr_t first_length=strlen(first_get_response);
intptr_t key_length=strlen(key);
intptr_t middle_length=strlen(middle);
intptr_t s_length=strlen(s);
intptr_t command_end_length=strlen(command_end);
intptr_t length=first_length+key_length+middle_length+s_length+command_end_length;
char *c=(char *)alloc_mem(pool,length);
memset(c,0,length);
intptr_t index=0;
memcpy(c,first_get_response,first_length);
index+=first_length;
memcpy(c+index,key,key_length);
index+=key_length;
memcpy(c+index,middle,middle_length);
index+=middle_length;
memcpy(c+index,s,s_length);
index+=s_length;
memcpy(c+index,command_end,command_end_length);
index+=command_end_length;
free_mem(s);
item_t *i=init_item();
i->data=c;
i->c_size=length;
return i;
}
void
index_submap_add(struct tile_info *info, struct tile_head *th)
{
int tlen=tile_len(th->name);
int len=tlen;
char *index_tile;
struct rect r;
struct item_bin *item_bin;
index_tile=g_alloca(len+1+strlen(info->suffix));
strcpy(index_tile, th->name);
if (len > 6)
len=6;
else
len=0;
index_tile[len]=0;
strcat(index_tile, info->suffix);
tile_bbox(th->name, &r, overlap);
item_bin=init_item(type_submap);
item_bin_add_coord_rect(item_bin, &r);
item_bin_add_attr_range(item_bin, attr_order, (tlen > 4)?tlen-4 : 0, 255);
item_bin_add_attr_int(item_bin, attr_zipfile_ref, th->zipnum);
tile_write_item_to_tile(info, item_bin, NULL, index_tile);
}
static item_t *get_direct_stat(){
item_t *i=init_item();
i->data=alloc_mem(pool,STAT_LINE_BUFFER_SIZE);
snprintf(i->data,STAT_LINE_BUFFER_SIZE,"buddy_mem-direct_size:%ld\n",stat->direct_size);
i->end=1;
i->c_size=strlen(i->data);
return i;
}
static void write_delete_response(connection_t *conn){
item_t *i=init_item();
intptr_t length=strlen(deleted);
char *del=(char *)alloc_mem(pool,length);
memcpy(del,deleted,length);
i->data=del;
i->c_size=length;
push(conn->wc->w_queue,i);
}
static item_t* fill_get_response_footer(){
intptr_t length=strlen(data_end);
char *c=(char *)alloc_mem(pool,length);
memcpy(c,data_end,length);
item_t *i=init_item();
i->data=c;
i->c_size=length;
return i;
}
static void write_set_response(connection_t *conn){
intptr_t length=strlen(set_response);
char *c=(char *)alloc_mem(pool,length);
memcpy(c,set_response,length);
item_t *i=init_item();
i->data=c;
i->c_size=length;
push(conn->wc->w_queue,i);
event_operation.register_event(conn->fd,WRITE,conn->ec,conn);
}
static void process_version(connection_t *conn){
char *c=(char *)alloc_mem(pool,strlen(version)+1);
item_t *i=init_item();
i->data=c;
i->c_size=strlen(version);
i->end=1;
strcpy(c,version);
push(conn->wc->w_queue,i);
event_operation.register_event(conn->fd,WRITE,conn->ec,conn);
}
static intptr_t process_set_body(connection_t *conn){
//check一下当前buffer数据的剩余多少
buffer_t *b=conn->rbuf;
intptr_t count=b->limit-b->current;
if(count==0){
return AGAIN;
}
//开始存储set数据
read_context_t *rc=conn->rc;
char *key=rc->key->data;
queue_t *q=(queue_t *)get(key,hash);
if(q==NULL){
//初始化队列，加入hash中
q=init_queue();
char *q_name=(char *)alloc_mem(pool,strlen(key));
strcpy(q_name,key);
put(q_name,q,hash);
//开始统计这个队列
start_queue_stat(q_name);
}
intptr_t fill=0;
intptr_t result=AGAIN;
item_t *i=init_item();
i->size=rc->last_bytes-2;
//如果当前buffer的数据包含了所有的set数据包括最后的/r/n
if(count>=rc->last_bytes){
fill=rc->last_bytes;
i->end=1;
result=OK;
write_set_response(conn);
//加入队列数据统计
increase_queue_stat(key,i->size);
}else{
//如果buffer不够了那么先把这部分数据copy出来，放入一个item中
fill=count;
rc->last_bytes-=fill;
}
char *c=(char *)alloc_mem(pool,fill);
memset(c,0,fill);
memcpy(c,b->data+b->current,fill);
i->data=c;
i->c_size=fill;
push(q,i);
add_set_sync_data(key,i);
b->current+=fill;
return result;
}
static int create_hook(Quark *q, void *udata, QTraverseClosure *closure)
{
TreeItem *item;
ExplorerUI *eui = (ExplorerUI *) udata;
Quark *qparent = quark_parent_get(q);
item = TreeInsertItem(eui->tree, quark_get_udata(qparent), q, quark_get_id(q));
init_item(eui, item, q);
quark_set_udata(q, item);
return TRUE;
}
void
index_init(struct zip_info *info, int version)
{
struct item_bin *item_bin;
int i;
map_information_attrs[0].type=attr_version;
map_information_attrs[0].u.num=version;
item_bin=init_item(type_map_information);
for (i = 0 ; i < 32 ; i++) {
if (!map_information_attrs[i].type)
break;
item_bin_add_attr(item_bin, &map_information_attrs[i]);
}
item_bin_write(item_bin, zip_get_index(info));
}
static item_t *get_buddy_stat(intptr_t *data,const char *type){
item_t *i=init_item();
i->data=alloc_mem(pool,STAT_LINE_BUFFER_SIZE);
snprintf(i->data,STAT_LINE_BUFFER_SIZE,"buddy_mem-%s 0:%lu 1:%lu 2:%lu 3:%lu 4:%lu 5:%lu 6:%lu 7:%lu\n",type,*data,
*(data+1),
*(data+2),
*(data+3),
*(data+4),
*(data+5),
*(data+6),
*(data+7)
);
i->end=1;
i->c_size=strlen(i->data);
return i;
}
static void get_queue_stat(connection_t *conn){
list_head_t *head=visit_hash(stat->queue_data_hash);
while(!list_is_empty(head)){
hash_entry_t *entry=(hash_entry_t *)list_entry(head->next,hash_entry_t,list);
queue_stat_t *qs=(queue_stat_t *)entry->data;
item_t *i=init_item();
i->data=alloc_mem(pool,STAT_LINE_BUFFER_SIZE);
i->end=1;
snprintf(i->data,STAT_LINE_BUFFER_SIZE,"queue_name:%s,size:%ld,bytes:%ld\n",qs->name,qs->size,qs->bytes);
i->c_size=strlen(i->data);
push(conn->wc->w_queue,i);
free_mem(entry);
list_del_data(head,head->next->next);
}
free_mem(head);
}
TEST(List, Sorted)
{
int size;
Item *head = 0;
Item *item = 0;
int num = 100;
Item items[num];
// Initialise each item
for (int i = 0; i < num; i++)
{
init_item(& items[i], i);
}
int block[num];
rand_array(block, num);
// add our items randomly to sorted list
for (int i = 0; i < num; i++)
{
int idx = block[i];
item = & items[idx];
item_add_sorted(& head, item, 0);
}
// Pop off stack : it should be in order
for (int i = 0; i < num; i++)
{
item = item_pop(& head);
EXPECT_TRUE(item);
// check it is the correct item
EXPECT_EQ(& items[i], item);
// check the item is correct
item_validate(item, i);
}
EXPECT_EQ(0, head);
item = item_pop(& head);
EXPECT_EQ(0, item);
size = item_size(& head);
EXPECT_EQ(0, size);
}
TEST(List, Stack)
{
int size;
Item *head = 0;
size = list_size((pList*) & head, pnext_item, 0);
EXPECT_EQ(0, size);
Item *item = 0;
int num = 100;
Item items[num];
// Initialise each item
for (int i = 0; i < num; i++)
{
init_item(& items[i], i);
}
// Push onto stack
for (int i = 0; i < num; i++)
{
list_push((pList*) & head, (pList) & items[i], pnext_item, 0);
size = item_size(& head);
EXPECT_EQ(i+1, size);
}
// Pop off stack
for (int i = num-1; i >= 0; i--)
{
item = item_pop(& head);
EXPECT_TRUE(item);
// check it is the correct item
EXPECT_EQ(& items[i], item);
size = item_size(& head);
EXPECT_EQ(i, size);
// check the item is correct
item_validate(item, i);
}
EXPECT_EQ(0, head);
item = item_pop(& head);
EXPECT_EQ(0, item);
}
void * thrash(void *arg)
{
ASSERT(arg);
ThreadTest *tt = (ThreadTest*) arg;
Item **head = & tt->head;
Mutex *mutex = & tt->mutex;
Item *item = 0;
int num = 100;
Item items[num];
// Initialise each item
for (int i = 0; i < num; i++)
{
init_item(& items[i], i);
}
// create a randomised table of indexes
int block[num];
rand_array(block, num);
// add our items randomly to sorted list
for (int i = 0; i < num; i++)
{
int idx = block[i];
item = & items[idx];
item_add_sorted(head, item, mutex);
}
// Remove the items
for (int i = 0; i < num; i++)
{
item = & items[i];
bool found = item_remove(head, item, mutex);
EXPECT_TRUE(found);
// check it is the correct item
EXPECT_EQ(& items[i], item);
// check the item is correct
item_validate(item, i);
}
return 0;
}
static MyConfigItem* section_create_item(MyConfigSection *self, const char *key, const char *value)
{
MyConfigItem *item = self->get_item(self, key);
if (item != NULL) {
return NULL;
}
item = (MyConfigItem *)malloc(sizeof(MyConfigItem));
if (item == NULL) {
fprintf(stderr, "failed to malloc item\n");
return NULL;
}
init_item(item);
item->set_key(item, key);
item->set_value(item, value);
self->item_list->append(self->item_list, item);
return item;
}
static void
ch_process_node(FILE *out, int node, int resolve)
{
int first_edge_id=nodes[node].first_edge;
int last_edge_id=nodes[node+1].first_edge;
int edge_id;
struct ch_edge ch_edge;
struct item_bin *item_bin;
struct edge_hash_item fwd,rev;
int oldnode;
memset(&ch_edge, 0, sizeof(ch_edge));
item_bin=init_item(type_ch_node);
oldnode=GPOINTER_TO_INT(g_hash_table_lookup(newnode_hash, GINT_TO_POINTER(node)));
#if 0
dbg(lvl_debug,"0x%x,0x%x\n",node_index[oldnode].x,node_index[oldnode].y);
#endif
item_bin_add_coord(item_bin, &node_index[oldnode], 1);
fwd.first=oldnode;
rev.last=oldnode;
for (edge_id = first_edge_id ; edge_id < last_edge_id ; edge_id++) {
if (resolve) {
struct edge *edge=&edges[edge_id];
int oldnode=GPOINTER_TO_INT(g_hash_table_lookup(newnode_hash, GINT_TO_POINTER((int)edge->target)));
struct item_id *id;
ch_edge.weight=edge->weight;
fwd.last=oldnode;
rev.first=oldnode;
ch_edge.flags=edge->flags & 3;
if (edge->scmiddle == 67108863) {
id=g_hash_table_lookup(edge_hash, &fwd);
if (!id) {
ch_edge.flags|=8;
id=g_hash_table_lookup(edge_hash, &rev);
}
if (id == NULL) {
fprintf(stderr,"Shortcut %d Weight %d\n",edge->scmiddle,edge->weight);
fprintf(stderr,"Neither %d-%d nor %d-%d exists\n",fwd.first,fwd.last,rev.first,rev.last);
exit(1);
} else {
ch_edge.middle=*id;
#if 0
dbg(lvl_debug,"middle street id for is "ITEM_ID_FMT"\n",ITEM_ID_ARGS(*id));
#endif
}
} else {
ch_edge.flags|=4;
id=g_hash_table_lookup(sgr_nodes_hash, GINT_TO_POINTER((int)edge->scmiddle));
dbg_assert(id != NULL);
ch_edge.middle=*id;
#if 0
dbg(lvl_debug,"middle node id for is "ITEM_ID_FMT"\n",ITEM_ID_ARGS(*id));
#endif
}
id=g_hash_table_lookup(sgr_nodes_hash, GINT_TO_POINTER((int)edge->target));
#if 0
dbg(lvl_debug,"id for %d is "ITEM_ID_FMT"\n",edge->target,ITEM_ID_ARGS(*id));
#endif
if (id == NULL) {
fprintf(stderr,"Failed to look up target %d\n",edge->target);
} else {
ch_edge.target=*id;
}
}
item_bin_add_attr_data(item_bin,attr_ch_edge,&ch_edge,sizeof(ch_edge));
}
item_bin_write(item_bin, out);
}
void
write_tilesdir(struct tile_info *info, struct zip_info *zip_info, FILE *out)
{
int idx,len,maxlen;
GList *next,*tiles_list;
char **data;
struct tile_head *th,**last=NULL;
tiles_list=get_tiles_list();
info->tiles_list=&tiles_list;
if (! info->write)
create_tile_hash_list(tiles_list);
next=g_list_first(tiles_list);
last=&tile_head_root;
maxlen=info->maxlen;
if (! maxlen) {
while (next) {
if (strlen(next->data) > maxlen)
maxlen=strlen(next->data);
next=g_list_next(next);
}
}
len=maxlen;
while (len >= 0) {
#if 0
fprintf(stderr,"PROGRESS: collecting tiles with len=%d\n", len);
#endif
next=g_list_first(tiles_list);
while (next) {
if (strlen(next->data) == len) {
th=g_hash_table_lookup(tile_hash, next->data);
if (!info->write) {
*last=th;
last=&th->next;
th->next=NULL;
th->zipnum=zip_get_zipnum(zip_info);
fprintf(out,"%s:%d",strlen((char *)next->data)?(char *)next->data:"index",th->total_size);
for ( idx = 0; idx< th->num_subtiles; idx++ ) {
data= th_get_subtile( th, idx );
fprintf(out,":%s", *data);
}
fprintf(out,"\n");
}
if (th->name[strlen(info->suffix)])
index_submap_add(info, th);
zip_add_member(zip_info);
processed_tiles++;
}
next=g_list_next(next);
}
len--;
}
if (info->suffix[0] && info->write) {
struct item_bin *item_bin=init_item(type_submap);
item_bin_add_coord_rect(item_bin, &world_bbox);
item_bin_add_attr_range(item_bin, attr_order, 0, 255);
item_bin_add_attr_int(item_bin, attr_zipfile_ref, zip_get_zipnum(zip_info)-1);
item_bin_write(item_bin, zip_get_index(zip_info));
}
}
TEST(List, Remove)
{
int size;
Item *head = 0;
//Item *item = 0;
int num = 100;
Item items[num];
// Initialise each item
for (int i = 0; i < num; i++)
{
init_item(& items[i], i);
}
// Append to stack
for (int i = 0; i < num; i++)
{
list_append((pList*) & head, (pList) & items[i], pnext_item, 0);
size = item_size(& head);
EXPECT_EQ(i+1, size);
}
size = item_size(& head);
EXPECT_EQ(num, size);
// Remove last item
bool found;
int i = num - 1;
Item *item = & items[i];
found = item_remove(& head, item, 0);
EXPECT_EQ(true, found);
item_validate(item, i);
// check it has gone
size = item_size(& head);
EXPECT_EQ(num-1, size);
// can't remove it twice
found = item_remove(& head, item, 0);
EXPECT_EQ(false, found);
// Remove the first item
i = 0;
item = & items[i];
found = item_remove(& head, item, 0);
EXPECT_EQ(true, found);
// check it has gone
size = item_size(& head);
EXPECT_EQ(num-2, size);
// can't remove it twice
found = item_remove(& head, item, 0);
EXPECT_EQ(false, found);
// Remove from the middle
i = num / 2;
item = & items[i];
found = item_remove(& head, item, 0);
EXPECT_EQ(true, found);
// check it has gone
size = item_size(& head);
EXPECT_EQ(num-3, size);
// can't remove it twice
found = item_remove(& head, item, 0);
EXPECT_EQ(false, found);
// pop the rest off
while (item_pop(& head))
{
}
// Try removing from an empty list
EXPECT_EQ(0, head);
found = item_remove(& head, item, 0);
EXPECT_EQ(false, found);
}
