static void aostk_free_traverse(struct list_head* l) { struct list_head* it; struct aostk_widget* w; list_for_each(it, l) { w = child_to_widget(it); aostk_free_traverse(&w->childlist); // printf("Deleting child %s\n", w->name); list_erase(&w->childnode); // Remove from parent-widgets list list_erase(&w->widgetnode); // Remove from global widget-list free(w); }
Node* list_erase(Node* n, Node* pos) { if (get_next(n) == NULL) { std::cerr << "ERROR" << std::endl; exit(1); } else if (n == pos) { Node* next_node = get_next(n); if (get_elem(n) && symbolp(get_elem(n))) { free((n->elem_m)->symbol_m); } free(n->elem_m); n->elem_m = get_elem(next_node); n->next_m = get_next(next_node); free(next_node); return n; } else if (get_next(n) == pos) { n->next_m = get_next(pos); if (get_elem(pos) && symbolp(get_elem(pos))) { free((pos->elem_m)->symbol_m); } free(pos->elem_m); free(pos); return n->next_m; } else { return list_erase(get_next(n), pos); } }
int main() { List *list = list_create(); if (!list) std::cout << "List creation error\n"; list_insert(list, 1); list_insert(list, 2); list_insert(list, 3); if (list_item_data(list_first(list)) != 3) std::cout << "list_insert error\n"; list_insert_after(list, list_first(list), 4); if (list_item_data(list_item_next(list_first(list))) != 4) std::cout << "list_insert_after error\n"; list_erase(list, list_first(list)); if (list_item_data(list_first(list)) != 4) std::cout << "list_erase error\n"; std::cout << "List: "; for (ListItem *item = list_first(list) ; item ; item = list_item_next(item)) { std::cout << list_item_data(item) << " "; } std::cout << "\n"; list_delete(list); }
//功 能: 更改定时器间隔时间并重新开始计时 //描 叙: 更改定时器间隔时间并重新开始计时 //参 数: id: 定时器ID // timeInterval: 间隔时间,以毫秒为单位 //返回值: 错误返回TIMER_ERROR,正确返回TIMER_OK int ChangeTimerTime(USHORT id, long timeInterval) { if (id >= MAX_TIMER_NUMBER || timeInterval <= 0) { LOG_WRITE_POS(LOG_WARNING, "Parameter error, id=%d, max id=%d, timeInterval=%ld\n", id, MAX_TIMER_NUMBER-1, timeInterval); return TIMER_ERROR; } sem_wait(&g_sem); if (g_timerArray[id].state == 0) { LOG_WRITE_POS(LOG_WARNING, "Parameter error, id=%d, state=%d\n", id, g_timerArray[id].state); sem_post(&g_sem); return TIMER_ERROR; } struct timeval tv={0, 0}; gettimeofday (&tv , NULL); g_timerArray[id].interval.tv_sec = timeInterval / 1000; g_timerArray[id].interval.tv_usec = timeInterval % 1000 * 1000; g_timerArray[id].tv.tv_sec = (tv.tv_sec + g_timerArray[id].interval.tv_sec) + (tv.tv_usec + g_timerArray[id].interval.tv_usec) / 1000000; g_timerArray[id].tv.tv_usec = (tv.tv_usec + g_timerArray[id].interval.tv_usec) % 1000000; list_erase(&g_timerArray[id].list); insertTimer(id); sem_post(&g_sem); return TIMER_OK; }
int list_uniq(t_list* list, t_func_cmp cmp, t_func_clear clear) { t_node* cur; t_node* tmp; size_t size; if (!list || !list->__head__ || !cmp) return (0); cur = list->__head__; size = list->__size__; while (cur) { tmp = list->__head__; while (tmp) if (tmp != cur && cmp(tmp->data, cur->data)) { list_erase(list, tmp->data, clear); tmp = NULL; } else tmp = tmp->next; cur = cur->next; } return (size == list->__size__); }
/*! \brief Release the connection's resources */ static void hc_delete(HttpConnection* connection) { //HttpServer* server = connection->server; log(INFO, "Http connection closed socket=%p", connection->sock); /* call the close callback if there is any */ if(connection->close_callback != NULL) { connection->close_callback(connection->close_data); } /* delete the socket */ sock_delete(connection->sock); /* erase the connection from the list of connections */ list_erase(connection->it); /* free header */ if(connection->header != NULL) { http_delete(connection->header); connection->header = NULL; } /* free memory */ HttpConnection_free(connection); }
element_t list_pop_back(list_t L) { list_node_t node = (list_node_t)list_end(L); if (NULL != node) node = node->prev; return list_erase(L, (list_iter_t)node); }
element_t list_pop_back(list_t l) { ASSERT_LIST(l); ASSERT_LIST_UNDERFLOW(l); return list_erase(l, l->head.next); }
element_t list_pop_front(list_t l) { ASSERT_LIST(l); ASSERT_LIST_UNDERFLOW(l); return list_erase(l, (&l->head)->prev); }
List *list_erased(List *l) { if (l->data) { free(l->data); l->data = 0; } return list_erase(l); }
int hash_erase(HashTable *table,const ListElement *element,CompareElementFuncType equal,DestroyElementFuncType destroy) { unsigned int hash=0; assert(table && element && equal && destroy); hash=hash_value((*table->elmtostr_fptr)(element),table->size); return list_erase(&table->hashbucket[hash].list,element,equal,destroy); }
/** * Cleans up a client for exit */ void server_client_cleanup(server_t* server, client_t* client) { ev_io_stop(server->io_loop, &client->io_read); list_erase(&server->client_list, &client->node); object_free(&client->read_buffer); object_free(&client->write_buffer); server->drop_cb(client, server); close(client->fd); }
int32_t list_remove(struct list *l,void *v) { assert(l); struct list_iter it = list_find(l,v); if(it.n == 0) return 0; list_erase(l,it); return 1; }
void dsdict_remove(dsdict* dict, const char* key) { dsdict_node* node = dsdict_iter(dict, key); if (node) { dfree(node->key); dfree(node->value); list_erase(dict, node); free(node); } }
int del_listRead(st_sock* sts, s_link *pslink) { sem_wait(&sts->semListRead); if (!list_empty(&sts->stIDListMsgRead[pslink->id].list)) { list_erase(&sts->stIDListMsgRead[pslink->id].list); //list_init(&sts->stIDListMsgRead[pslink->id].list); } sem_post(&sts->semListRead); return EX_UDP_OK; }
static void task_ev_wait_erase(struct k9_task * const task) { struct k9_ev_wait_desc *w; unsigned n; for (w = task->u->blocked->ev->wait, n = task->u->blocked->ev->nwait; n; --n, ++w) { list_erase(w->list_node); } tmout_erase(task); }
void list_clear(list_t l) { list_node_t iter, node; ASSERT_LIST(l); iter = l->head.next; while (iter != &l->head) { node = iter; iter = iter->next; list_erase(l, iter); } l->size = 0; }
/** * Opens a directory in cache fs form (ie. client cached index + data files) */ int cache_open_fs_dir(cache_t* cache, const char* directory) { DIR *dir = opendir(directory); struct dirent *entry; int num_indices = 0; sorted_list_t* index_list = object_new(sorted_list); index_list->compare_func = strcmp_wrap; if (dir == NULL) { return 1; } char data_file[256]; while ((entry = readdir(dir)) != NULL) { if (strstr(entry->d_name, "idx")) { index_list_node_t* node = (index_list_node_t*)malloc(sizeof(index_list_node_t)); strcpy(node->index, entry->d_name); sorted_list_insert(index_list, &node->node); num_indices++; } else if (strstr(entry->d_name, "dat")) { sprintf(data_file, "%s/%s", directory, entry->d_name); } } if (data_file == NULL || num_indices == 0) { return 1; } char** index_files = (char**)malloc(sizeof(char*)*num_indices); int i = 0; while (!list_empty(&index_list->list)) { list_node_t* node = list_front(&index_list->list); index_list_node_t* index_node = container_of(node, index_list_node_t, node); index_files[i] = (char*)malloc(sizeof(char)*256); sprintf(index_files[i++], "%s/%s", directory, (char*)index_node->index); list_erase(&index_list->list, node); free(index_node); } object_free(index_list); closedir(dir); cache_open_fs(cache, num_indices, (const char**)index_files, data_file); for (int i = 0; i < num_indices; i++) { free(index_files[i]); } free(index_files); return 0; }
void menu_item_remove(struct menu_item *item) { if (!item->destroy_proc || !item->destroy_proc(item)) { if (item->imenu) { menu_destroy(item->imenu); free(item->imenu); } if (item->text) free(item->text); if (item->data) free(item->data); } menu_deselect(item->owner, item); list_erase(&item->owner->items, item); }
int main() { char* first = malloc(sizeof(char)); *first = 'b'; char* second = malloc(sizeof(char)); *second = 'o'; char* third = malloc(sizeof(char)); *third = 'n'; char* fourth = malloc(sizeof(char)); *fourth = 'v'; char* fifth = malloc(sizeof(char)); *fifth = 'h'; char* sixth = malloc(sizeof(char)); *sixth = 'a'; char* seventh = malloc(sizeof(char)); *seventh = 'm'; char* eighth = malloc(sizeof(char)); *eighth = 'X'; list l1 = NULL; list_init(&l1, first); list_append(&l1, second); list_append(&l1, third); list_append(&l1, fourth); list l2 = list_new(); list_append(&l2, fifth); list_append(&l2, sixth); list_append(&l2, seventh); list_append(&l2, eighth); list_extend(&l1, &l2); list_erase(&l1, list_find(l1, 'X')); list_remove(&l1, 'v'); list_print(l1); return list_delete(l1); }
void list_clear(list_t L, void (*destroy)(void*)) { list_node_t it, node; element_t data; if (NULL == L) return; it = L->node.next; while (it != &L->node) { node = it; it = it->next; data = list_erase(L, (list_iter_t)node); if (NULL != destroy) destroy(data); } }
//功 能: 关闭对应id的定时器 //描 叙: 关闭对应id的定时器任务 //参 数: id: 设置新定时器时返回的id值 //返回值: 无 void KillTimer(USHORT id) { if (id >= MAX_TIMER_NUMBER) { LOG_WRITE_POS(LOG_NOTICE, "Parameter error, id=%d, max id=%d\n", id, MAX_TIMER_NUMBER-1); return; } sem_wait(&g_sem); if (g_timerArray[id].state == 0) { LOG_WRITE_POS(LOG_NOTICE, "Parameter error, id=%d, state=%d\n", id, g_timerArray[id].state); sem_post(&g_sem); return; } list_erase(&g_timerArray[id].list); g_timerArray[id].state = 0; list_push_back(&g_listTimerFree, &g_timerArray[id].list); printf_debug3("KillTimer id=%d\n", id) ; sem_post(&g_sem); return; }
int k9_task_delete(struct k9_task *task) { uint32 old; unsigned f = 0; task = task_or_self(task); old = k9_cpu_intr_dis(); switch (task->state) { case K9_TASK_STATE_STOPPED: case K9_TASK_STATE_EXITED: case K9_TASK_STATE_FAULTED: break; default: return (-1); } list_erase(task->list_node); k9_cpu_intr_restore(old); }
static void List_dispose(List *self) { list_erase(self,self->first,NULL); }
void list_pop_back(List *l) { list_erase(list_back(l)); }
void list_pop_front(List *l) { list_erase(list_front(l)); }
element_t list_pop_front(list_t L) { return list_erase(L, list_begin(L)); }
void list_remove(List *l, void *data) { List *l2; while ((l2 = list_find(l, data))) l = list_erase(l2); }
int test_run (void) { SCL_list_t list; SCL_iterator_t iterator; void* data; int stat; int i; printf ("Create list: "); fflush (stdout); list = list_new(); printf ("(%p = list_new()) != NULL ....... ", list); fflush (stdout); printf ("%s\n", ((list!=NULL) ? "PASS" : "FAIL")); printf ("Push data in back list.\n"); for (i=0 ; i<LIST1_SIZE ; i++) { stat = list_push_back (list, (void*)g_data1[i]); printf ( "([%d,%s] = list_push_back (list, data[%d]) .... %s\n", stat, scl_statstr(stat), i, ((stat==SCL_OK) ? "PASS" : "FAIL") ); } printf ( "%2ld = list_count (list) .......................... %s\n", list_count(list), ((list_count(list)==LIST1_SIZE) ? "PASS" : "FAIL") ); printf ("Foreach on list.\n"); for (i=0 ; i<LIST1_SIZE ; i++) g_flag1[i] = 0; list_foreach (list, cbfn1, NULL); printf ("Insert data in list before 2 using iterator.\n"); iterator = list_at (list, 2); printf ("%p = list_at (list, 2);\n", iterator); stat = list_insert_before (list, iterator, (void*)0x0101); printf ( "[%d,%s] = list_insert_before (list, iterator=>%p, %08X);\n", stat, scl_statstr(stat), iterator, 0x0101 ); printf ("Insert data in list after 3 using iterator.\n"); iterator = list_at (list, 3); printf ("%p = list_at (list, 3);\n", iterator); stat = list_insert_after (list, iterator, (void*)0xAAAAAAAA); printf ( "[%d,%s] = list_insert_after (list, iterator=>%p, %08X);\n", stat, scl_statstr(stat), iterator, 0xAAAAAAAA ); printf ( "%2ld = list_count (list) .......................... %s\n", list_count(list), ((list_count(list)==LIST2_SIZE) ? "PASS" : "FAIL") ); printf ("Foreach on list.\n"); for (i=0 ; i<LIST2_SIZE ; i++) g_flag2[i] = 0; list_foreach (list, cbfn2, NULL); printf ("REVERSE the list.\n"); list_reverse (list); printf ( "%2ld = list_count (list) .......................... %s\n", list_count(list), ((list_count(list)==LIST3_SIZE) ? "PASS" : "FAIL") ); printf ("Foreach on list.\n"); for (i=0 ; i<LIST3_SIZE ; i++) g_flag3[i] = 0; list_foreach (list, cbfn3, NULL); printf ("Erase list.\n"); list_erase (list); printf ( "%2ld = list_count (list) .......................... %s\n", list_count(list), ((list_count(list)==0) ? "PASS" : "FAIL") ); printf ("Delete list.\n"); list_del (list); printf ("\n"); return 0; }
void stack_pop(Stack *stack) { List *tmp = stack->list; list_erase(tmp, list_first(stack->list)); }