Floor new_floor (int floor_number) { Floor f; f.number = floor_number; f.request_button[0] = 0; f.request_button[1] = 0; f.queue = llist_new(); f.in_floor = llist_new(); f.stair_case = llist_new(); return f; }
static LinkedList *adapters() { if (! _adapters){ _adapters = llist_new(); } return _adapters; }
/** * Returns the list of loaded transcodings plugins * @return list of transcoding plugins */ static LinkedList *plugins() { if (! _plugins) { _plugins = llist_new(); } return _plugins; }
static LinkedList *devices() { if (! _devices) { _devices = llist_new(); } return _devices; }
Stack* stack_new() { Stack* st=(Stack*)malloc(sizeof(Stack)); //st->list=(LList*)malloc(sizeof(LList)); st->list=llist_new(); return (st); }
static LinkedList *tcp_clients() { if ( ! _tcp_clients) { _tcp_clients = llist_new(); } return _tcp_clients; }
static LinkedList *channels() { if (! _channels){ _channels = llist_new(); } return _channels; }
static LinkedList *apps() { if (! _apps) { _apps = llist_new(); } return _apps; }
int main(){ int D,N; scanf("%d%d",&D,&N); LList*peg_1=llist_new(); LList*peg_2=llist_new(); LList*peg_3=llist_new(); int i=1; while(i<=D){ peg_1=llist_append(peg_1,i); i++; } int num_of_steps = 0; num_of_steps = play_TOH(peg_1,peg_2,peg_3); printf(" No of steps= %d\n",num_of_steps); return 0; }
static char* test_newlist() { linked_list* list = llist_new(); mu_assert("** test_newlist: linked_list creation failed.", list != NULL); mu_assert("** test_newlist: head not null.", list->head == NULL); mu_assert("** test_newlist: tail not null.", list->tail == NULL); mu_assert("** test_newlist: size not 0.", list->size == 0); return 0; }
streambuf_t *streambuf_new(size_t h_limit) { struct streambuf_st *buf; pthread_once(&init_once, init_cache); buf = malloc(sizeof(*buf)); if (h_limit < BUFVOL_MAX) { buf->ringbuf = llist_new(BUFVOL_MAX * 2); } else { buf->ringbuf = llist_new(h_limit * 2); } buf->h_limit = h_limit; buf->nr_bytes = 0; pthread_mutex_init(&buf->mut, NULL); pthread_cond_init(&buf->cond, NULL); return buf; }
int cllist_new(void **cllist) { cLinkedList **_cllist = (cLinkedList **)cllist; *_cllist = (cLinkedList *)malloc(sizeof(cLinkedList)); llist_new((void **) & ((*_cllist)->llist)); pthread_mutex_init(&((*_cllist)->mutex), NULL); return 0; }
Lift* create_lift() { int floor_num; Lift* l = (Lift*)malloc(sizeof(Lift));; l->current_floor = 0; l->people = llist_new(); l->direction = 1; l->max_limit = 8; l->dests = llist_new(); l->counter = 0; l->max_count = 5; l->destination = 0; for( floor_num = 0; floor_num < NUM_OF_FLOORS; floor_num++ ) { l->panel[floor_num] = 0; } return l; }
static char* test_remove1() { linked_list* list = llist_new(); node* n = llist_insert(list, 1, 1); free(llist_remove(list, n)); mu_assert("** test_removehead: size != 0.", list->size == 0); mu_assert("** test_removehead: head != tail.", list->head == list->tail); mu_assert("** test_removehead: head != NULL.", list->head == NULL); return 0; }
static char* test_insert2() { linked_list* list = llist_new(); llist_insert(list, 1, 1); llist_insert(list, 2, 2); mu_assert("** test_insert2: head == tail.", list->head != list->tail); mu_assert("** test_insert2: head->next != tail.", list->head->next == list->tail); mu_assert("** test_insert2: tail->prev != head.", list->tail->prev == list->head); mu_assert("** test_insert2: size != 2.", list->size == 2); return 0; }
/** * \brief Adds a new node at the end of the list. * Adds a new node at the end of the list. This method creates the node. * * \param list LLIST to handle * \param c complex number * \param iteration number of iteration that have been necessary to create * the new node * \return the complete LLIST with the new element attached to it */ LLIST * llist_append (LLIST * list, complex c, unsigned int iteration) { LLIST * currentNode = list; while (currentNode->next != NULL) { currentNode = currentNode->next; } currentNode->next = llist_new(c, iteration, NULL); return list; }
static char* test_insert1() { linked_list* list = llist_new(); node* n = llist_insert(list, 1, 1); mu_assert("** test_insert1: n->key != 1", n->key == 1); mu_assert("** test_insert1: n->data != 1", n->data == 1); mu_assert("** test_insert1: unable to insert node.", list->head != NULL); mu_assert("** test_insert1: head and tail not equal.", list->head == list->tail); mu_assert("** test_insert1: size != 1", list->size == 1); mu_assert("** test_insert1: head->next != null.", list->head->next == NULL); mu_assert("** test_insert1: head->prev != null.", list->head->prev == NULL); return 0; }
fslist_p fslist_new(void) { fslist_p fsp; fsp = (fslist_p) malloc(sizeof(fslist)); if (fsp) { pthread_rwlock_init(&fsp->lock, NULL); fsp->list = llist_new(); if (fsp->list == NULL) { free(fsp); return NULL; } } return fsp; }
/** * \brief Adds a new node at the beginning of the list. * Adds a new node at the beginning of the list. This method creates the node. * * \param list LLIST to handle * \param c complex number * \param iteration number of iteration that have been necessary to create * the new node * \return the complete LLIST with the new element attached to it */ LLIST * llist_prepend (LLIST * list, complex c, unsigned int iteration) { LLIST * newNode = llist_new(c,iteration, list); if (newNode == NULL) { return list; } else { return newNode; } }
void stack_print(Stack* st) { LList* new3=(LList*)malloc(sizeof(LList)); new3->head=(Node*)malloc(sizeof(Node)); LList* new2=(LList*)malloc(sizeof(LList)); new2->head=(Node*)malloc(sizeof(Node)); new3=llist_new(); new2->head=st->list->head; while (new2->head!=NULL) { new3=llist_prepend(new3,new2->head->data); new2->head=new2->head->next; } llist_print(new3); }
static char* test_remove3() { linked_list* list = llist_new(); llist_insert(list, 1, 1); node* n = llist_insert(list, 2, 2); llist_remove(list, n); mu_assert("** test_remove3: head != tail.", list->head == list->tail); mu_assert("** test_remove3: head->next != NULL.", list->head->next == NULL); mu_assert("** test_remove3: head->prev != NULL.", list->head->prev == NULL); mu_assert("** test_remove3: removed node != n.", n->key == 2); free(n); return 0; }
int main (void){ LNode my_List; LNode temp; void *ptr; ptr =NULL; arr_init(ptr); my_List=llist_new(ptr); temp=my_List; while (temp!=NULL){ printf("%d\n",temp->data); temp=temp->next; } //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! node_insert(my_List,888,21); temp=my_List; while (temp!=NULL){ printf("%d\n",temp->data); temp=temp->next; } //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! node_delete(my_List,21); temp=my_List; while (temp!=NULL){ printf("%d\n",temp->data); temp=temp->next; } return 0; }
static char* test_remove4() { linked_list* list = llist_new(); llist_insert(list, 1, 1); node* n = llist_insert(list, 2, 2); llist_insert(list, 3, 3); llist_remove(list, n); mu_assert("** test_remove4: head == tail.", list->head != list->tail); mu_assert("** test_remove4: head->next != tail.", list->head->next == list->tail); mu_assert("** test_remove4: tail->prev != head.", list->tail->prev == list->head); mu_assert("** test_remove4: head->prev != NULL.", list->head->prev == NULL); mu_assert("** test_remove4: tail->next != NULL.", list->tail->next == NULL); mu_assert("** test_remove4: head != 1.", list->head->key == 3); mu_assert("** test_remove4: tail != 3.", list->tail->key == 1); free(n); return 0; }
/** * Read a directory into a glib list. Each list entry should * be freed with free and the list with g_list_free. * FIXME: provide Iterator directory_iterator(const char *dir)! */ LList * read_directory(const char *dir) { DIR *dp; struct dirent *ep; LList *files = llist_new(); dp = opendir(dir); if (dp == NULL) return NULL; while ((ep = readdir(dp)) != NULL) llist_add(files, xstrdup(ep->d_name)); #if CLOSEDIR_VOID closedir(dp); #else if (closedir(dp) == -1) return NULL; #endif return files; }
/** * server_new * * Creates a server structure and initializes the variables * * @return s Returns the server structure */ server* server_new(void) { //int i; server *s = malloc(sizeof (server)); if (s == NULL) SystemFatal("Malloc() Failed \n"); s->pid = getpid(); s->n_clients = 0; s->n_max_connected = 0; s->n_max_bytes_received = 0; s->client_list = llist_new(); /*for (i = 0; i <= FD_SETSIZE; i++) { s->clients[i] = -1; }*/ if (pthread_mutex_init(&s->dataLock, NULL) != 0) { free(s); return NULL; } return s; }
void multi_thread_test() { llist_t *ll; ll = llist_new(2000); pthread_t pid[10]; /* * test 4 */ int i; for (i=0; i < 6; i++) { pthread_create(&pid[i], NULL, producer, ll); } for (i=6; i<10; i++) { pthread_create(&pid[i], NULL, consumer, ll); } for (i=0; i<10; i++) { pthread_join(pid[i], NULL); } printf("nodes is %d\n", ll->nr_nodes); llist_delete(ll); printf("%stest4 successful%s\n", COR_BEGIN, COR_END); }
StringHash * string_hash_new () { return (StringHash *) llist_new (sizeof (StringHashItem)); }
static struct i_bitmap * i_flood_fill_low(i_img *im,i_img_dim seedx,i_img_dim seedy, i_img_dim *bxminp, i_img_dim *bxmaxp, i_img_dim *byminp, i_img_dim *bymaxp, i_color const *seed, ff_cmpfunc cmpfunc) { i_img_dim ltx, rtx; i_img_dim tx = 0; i_img_dim bxmin = seedx; i_img_dim bxmax = seedx; i_img_dim bymin = seedy; i_img_dim bymax = seedy; struct llist *st; struct i_bitmap *btm; int channels; i_img_dim xsize,ysize; i_color cval; channels = im->channels; xsize = im->xsize; ysize = im->ysize; btm = btm_new(xsize, ysize); st = llist_new(100, sizeof(struct stack_element*)); /* Find the starting span and fill it */ ltx = i_lspan(im, seedx, seedy, seed, cmpfunc); rtx = i_rspan(im, seedx, seedy, seed, cmpfunc); for(tx=ltx; tx<=rtx; tx++) SET(tx, seedy); bxmin = ltx; bxmax = rtx; ST_PUSH(ltx, rtx, ltx, rtx, seedy+1, 1); ST_PUSH(ltx, rtx, ltx, rtx, seedy-1, -1); while(st->count) { /* Stack variables */ i_img_dim lx,rx; i_img_dim dadLx,dadRx; i_img_dim y; int direction; i_img_dim x; int wasIn=0; ST_POP(); /* sets lx, rx, dadLx, dadRx, y, direction */ if (y<0 || y>ysize-1) continue; if (bymin > y) bymin=y; /* in the worst case an extra line */ if (bymax < y) bymax=y; x = lx+1; if ( lx >= 0 && (wasIn = INSIDE(lx, y, seed)) ) { SET(lx, y); lx--; while(lx >= 0 && INSIDE(lx, y, seed)) { SET(lx,y); lx--; } } if (bxmin > lx) bxmin = lx; while(x <= xsize-1) { /* printf("x=%d\n",x); */ if (wasIn) { if (INSIDE(x, y, seed)) { /* case 1: was inside, am still inside */ SET(x,y); } else { /* case 2: was inside, am no longer inside: just found the right edge of a span */ ST_STACK(direction, dadLx, dadRx, lx, (x-1), y); if (bxmax < x) bxmax = x; wasIn=0; } } else { if (x > rx) goto EXT; if (INSIDE(x, y, seed)) { SET(x, y); /* case 3: Wasn't inside, am now: just found the start of a new run */ wasIn = 1; lx = x; } else { /* case 4: Wasn't inside, still isn't */ } } x++; } EXT: /* out of loop */ if (wasIn) { /* hit an edge of the frame buffer while inside a run */ ST_STACK(direction, dadLx, dadRx, lx, (x-1), y); if (bxmax < x) bxmax = x; } } llist_destroy(st); *bxminp = bxmin; *bxmaxp = bxmax; *byminp = bymin; *bymaxp = bymax; return btm; }
void func_test() { char *s = "this is a test"; char *s2 = "x"; void *b; int i, j; llist_t *ll; /* * test 1 */ ll = llist_new(20); for (i = 0; i < 4; i++) { if (i%3 == 0) { llist_append(ll, &s2[0]); } llist_append(ll, &s[i]); } llist_travel(ll, &show); printf("\n"); for (i = 0; i < 4; i++) { llist_prepend(ll, &s[0]); } llist_travel(ll, &show); printf("\n"); for (i = 0; i < 4; i++) { llist_prepend_nb(ll, &s[1]); } llist_travel(ll, &show); printf("\n"); llist_fetch_head(ll, &b); llist_travel(ll, &show); printf("\n"); llist_fetch_head(ll, &b); llist_travel(ll, &show); printf("\n"); llist_delete(ll); printf("%stest1 successful%s\n", COR_BEGIN, COR_END); /* * test 2 */ ll = llist_new(1000); for (j = 0; j < 100; j++) { for (i = 0; i < 10; i++) { llist_append_nb(ll, &s[i]); } } printf("append done.\n"); for (i = 0; i< 100; i++) { llist_fetch_head_nb(ll, &b); printf("%c", *(char *)b); } printf("\nthere are %d nodes\n", ll->nr_nodes); for (i = 0; i< 100; i++) { llist_get_head_nb(ll, &b); printf("%c", *(char *)b); } printf("\n"); printf("%stest2 successful%s\n", COR_BEGIN, COR_END); printf("there are %d nodes\n", ll->nr_nodes); /* * test 3 */ void *ptr, *ptr2; llist_get_head_node_nb(ll, &ptr); for (i = 0; i< 100; i++) { printf("%c", *(char *)(((llist_node_t *)ptr)->ptr)); ptr = llist_get_next_nb(ll, ptr); } printf("\nthere are %d nodes\n", ll->nr_nodes); llist_delete(ll); printf("%stest3 successful%s\n", COR_BEGIN, COR_END); return; }