int main() { struct queue q; int i, j, k; queue_init (&q, sizeof(int), 5); i = 1; queue_push(&q, &i); i = 2; queue_push(&q, &i); i = 3; queue_push(&q, &i); j = *(int*)queue_front(&q); k = *(int*)queue_back(&q); printf ("%d, %d\n", j, k); queue_pop(&q); j = *(int*)queue_front(&q); k = *(int*)queue_back(&q); printf ("%d, %d\n", j, k); queue_pop(&q); queue_pop(&q); i = 11; queue_push(&q, &i); i = 12; queue_push(&q, &i); i = 13; queue_push(&q, &i); i = 14; queue_push(&q, &i); i = 15; queue_push(&q, &i); i = 16; queue_push(&q, &i); j = *(int*)queue_front(&q); k = *(int*)queue_back(&q); printf ("%d, %d\n", j, k); while (!queue_empty(&q)) { int s = *(int*)queue_front(&q); queue_pop(&q); printf ("%d\n", s); } return 0; }
int main(void) { Student s1 = {45, "hello"}, s2 = {49, "world"}, * sptr; pQueue q = queue_new(sizeof(int)); pQueue ps = queue_new(sizeof(Student)); int value = 10, v = 12, *ip; queue_enqueue(q, &value); queue_enqueue(q, &v); ip = (int *)queue_front(q); printf("%d\n", *ip); queue_dequeue(q); ip = (int *)queue_front(q); printf("%d\n", *ip); queue_free(q); queue_enqueue(ps, &s1); queue_enqueue(ps, &s2); printf("queue size: %ld\n", queue_size(ps)); sptr = (Student *)queue_front(ps); printf("no: %d, name: %s\n", sptr->no, sptr->name); queue_dequeue(ps); printf("queue size: %ld\n", queue_size(ps)); sptr = (Student *)queue_front(ps); printf("no: %d, name: %s\n", sptr->no, sptr->name); queue_free(ps); exit(EXIT_SUCCESS); }
si_t application_exec() { /** * parse the application before execute **/ application_parse(); event_listener_add_read_event(&global_application.app_event_listener, &global_application.uds, NULL, application_event_handler, NULL); while(!queue_empty(&global_application.message_queue)) { union message* msg = queue_front(&global_application.message_queue); application_handle_message(msg); queue_pop(&global_application.message_queue); } global_application.exec_flag = 1; if(0 != event_listener_exec(&global_application.app_event_listener)) { EGUI_PRINT_ERROR("failed to run event_listener."); return -1; } global_application.exec_flag = 0; return 0; }
si_t application_event_handler(struct egui_uds* uds_ptr, addr_t arg) { union message msg; if(0 != comm_recv_msg(uds_ptr, &msg)) { EGUI_PRINT_ERROR("failed to recv msg"); return SELECTER_RETURN_TYPE_CONTINUE; } application_handle_message(&msg); /** * 处理器消息过程中,应用程序需要发送一些请求,等待回应的过程中,窗口管理器可能会发送消息。 * 因此当请求处理完毕之后,再逐一处理消息。 **/ while(!queue_empty(&global_application.message_queue)) { union message* msg = queue_front(&global_application.message_queue); application_handle_message(msg); queue_pop(&global_application.message_queue); } return SELECTER_RETURN_TYPE_CONTINUE; }
/** * 客户端请求处理函数:这个函数是selector里面的客户端的通信句柄对应的回调函数 **/ si_t client_request_handler(struct egui_uds* uds_ptr, addr_t arg) { struct queue message_queue; si_t ret = 0; NOT_USED(arg); EGUI_PRINT_INFO("callback client_request_handler() is called"); queue_init(&message_queue); /** 接受request回应respond **/ ret = comm_recv_request_and_send_respond(uds_ptr, &message_queue, request_handler); if(EXIT_NUMBER == ret) { return SELECTER_RETURN_TYPE_END; } /** 发送相关消息 **/ while(!queue_empty(&message_queue)) { union message* message_ptr = (union message*)queue_front(&message_queue); if(0 != comm_send_message(uds_ptr, message_ptr)) { EGUI_PRINT_ERROR("failed to send message!"); } queue_pop(&message_queue); } queue_exit(&message_queue); return SELECTER_RETURN_TYPE_CONTINUE; }
int main(void) { int a[10]; int i; queue_t *qt; int data; rand_a(a, 10); show_a(a, 10); qt = queue_create(sizeof(int), NULL); printf("=== enqueue ===\n"); for (i = 0; i < 10; i++ ) enqueue(qt, &a[i]); queue_front(qt, &data); printf("front is %d\n", data); printf("=== dequeue ===\n"); //while (!queue_isempty(qt)) { dequeue(qt, &data); printf("%2d ", data); } putchar('\n'); queue_destroy(qt); return 0; }
void dijkstra_distance_target(grid *distances, grid *target, const pos *targets, int count, int neighbors, cost_function_t cost_function, void *userdata){ grid_fill(distances, distances->x0, distances->y0, distances->width, distances->height, DBL_MAX); if(target != NULL) grid_fill(target, target->x0, target->y0, target->width, target->height, -1); queue open_set = queue_create(sizeof(pos)); for(int i = 0;i<count;++i) { grid_set(distances, targets[i].x, targets[i].y, 0.0); if(target != NULL) grid_set(target, targets[i].x, targets[i].y, i); queue_push(&open_set, targets+i); } while(!queue_empty(&open_set)) { pos cur = *(pos*)queue_front(&open_set); double curdist = grid_get(distances, cur.x, cur.y); queue_pop(&open_set); for(int i = 0;i<neighbors;++i) { pos neigh = {cur.x+offsets[i].x, cur.y+offsets[i].y}; if(!grid_contains(distances, neigh.x, neigh.y)) continue; double neighdist = grid_get(distances, neigh.x, neigh.y); double cost = cost_function(cur.x, cur.y, neigh.x, neigh.y, userdata); if(neighdist > curdist + cost) { grid_set(distances, neigh.x, neigh.y, curdist + cost); if(target != NULL) grid_set(target, neigh.x, neigh.y, grid_get(target, cur.x, cur.y)); queue_push(&open_set, &neigh); } } } queue_destroy(open_set); }
static void * watch(void *arg) { int fd, err; queue_t q; struct inotify_event *event; fd = ((struct watch_data_t *)arg)->fd; q = ((struct watch_data_t *)arg)->q; free(arg); while (1) { while (!queue_empty(q)) { event = queue_front(q); queue_dequeue(q); err = create_ihandler_thread(event); if (err < 0) err_msg("warning[watch]: Unable to spawn inotify event handler for event->wd #%d\n", event->wd); } if (event_check(fd) > 0) { int r; r = read_events(q, fd); if (r < 0) /* read(2) in read_events() returned an error. */ break; } } return NULL; }
uint8_t serial_get(void){ /* Agafem l'element superior del la cua de recpecio */ uint8_t a; while (queue_is_empty(&rx)); a=queue_front(&rx); queue_dequeue(&rx); return a; }
vertex_id_t* graph_topological_sort(graph_t* self) { vertex_id_t* ret; size_t current_id; vertex_t* current = NULL; adjacent_t* current_adjacent = NULL; size_t i; queue_t* q; graph_recompute(self, GRAPH_RECOMPUTE_REACHED_BIT | GRAPH_RECOMPUTE_INCOMING_BIT); q = queue_new(vertex_id_t); for (i = 0; i < self->size; ++i) if (self->v[i]->incoming_edges_count == 0) queue_push(q, i); if (queue_empty(q)) { queue_destroy(q); return NULL; } ret = (vertex_id_t*)malloc(self->size * sizeof(vertex_id_t)); if (!ret) { queue_destroy(q); return ret; } i = 0; while (!queue_empty(q)) { queue_front(q, ¤t_id); queue_pop(q); current = self->v[current_id]; ret[i++] = current_id; current_adjacent = current->adjacents_head; while (current_adjacent) { if (--(self->v[current_adjacent->id]->incoming_edges_count) == 0) queue_push(q, current_adjacent->id); current_adjacent = current_adjacent->next; } } queue_destroy(q); assert(i == self->size); return ret; }
static char *test_queue_two() { queue_t queue; queue_init(&queue); int x = 5, y = 6; queue_enqueue(&queue, &x); queue_enqueue(&queue, &y); int front = *(int *)queue_front(&queue); mu_assert_equals_int("Error: Incorrect value", x, front); mu_assert_equals_int("Error: Incorrect size", 2, queue_getsize(&queue)); queue_dequeue(&queue); front = *(int *)queue_front(&queue); mu_assert_equals_int("Error: Incorrect value", y, front); mu_assert_equals_int("Error: Incorrect size", 1, queue_getsize(&queue)); mu_assert("Error: queue reporting empty", !queue_isempty(&queue)); queue_destroy(&queue); return 0; }
int main () { int sq, eq, q[50], Max = 50; initialise_queue(&sq, &eq); add_to_queue(q, &sq, &eq, Max, 1); add_to_queue(q, &sq, &eq, Max, 2); add_to_queue(q, &sq, &eq, Max, 3); add_to_queue(q, &sq, &eq, Max, 4); print(q, &sq, &eq); pop_queue(&sq, &eq, Max); print(q, &sq, &eq); printf("\n%d", queue_front(q, &sq)); }
void second_pass (queue fifo) { while (!queue_empty(fifo)) { ast command_node = queue_front(fifo); ast first_param = get_first_param(command_node); ast parent_arg = command_node-> right; ast first_arg = parent_arg-> right; second_pass_aux(first_arg , first_param , parent_arg); queue_pop(fifo); } }
static char *test_queue_one() { queue_t queue; queue_init(&queue); int x = 5; queue_enqueue(&queue, &x); int front = *(int *)queue_front(&queue); mu_assert_equals_int("Error: Incorrect value", x, front); mu_assert("Error: queue reporting empty", !queue_isempty(&queue)); queue_destroy(&queue); return 0; }
static void departure_process(struct system_t *system) { struct customer_t customer = queue_pop(&system->queue); struct customer_t next_customer = queue_front(&system->queue); system->current_time = system->departure_time; system->total_served++; system->total_event++; //performance(system->current_time, customer.id, DEPARTURE); /* delay record */ if (next_customer.arrival_time != 0) { double delay_time = system->current_time - next_customer.arrival_time; if (delay_time > 0) { system->total_delay_time += delay_time; system->delay_customer_count++; } } /* 4.5 min */ if (system->current_time - customer.arrival_time > 4.5) system->total_4_5_customer++; if (system->queue.count == 0) { /* idle */ system->service_time = 0; system->departure_time = 0; system->idle_time = system->current_time; } else { if (system->queue.count > 1) { system->area += (system->queue.count - 1)*(system->current_time - system->preview_time); system->total_queue++; system->total_queue_customer += system->queue.count - 1; /* 1 for serverd */ system->max_queue_len = MAX(system->max_queue_len , system->queue.count - 1); } /* serve next customer */ system->service_time = get_time(DEPARTURE); system->total_service_time += system->service_time; system->departure_time = system->current_time + system->service_time; } system->preview_time = system->current_time; }
int main(void){ queue_t q; queue_empty(&q); queue_enqueue(&q,'f'); queue_enqueue(&q,'a'); queue_enqueue(&q,'r'); queue_enqueue(&q,'g'); queue_enqueue(&q,'a'); queue_enqueue(&q,'s'); while (!(queue_is_empty(&q))){ printf("%c \n",queue_front(&q)); queue_dequeue(&q); } return 0; }
int main() { int i; queue_t* q = queue_new(); assert(queue_empty(q)); for (i = 0; i < 10; ++i) queue_push(q, i); assert(!queue_empty(q)); assert(queue_front(q) == 0); while (!queue_empty(q)) { printf(" %d", queue_front(q)); queue_pop(q); } printf("\n"); queue_destroy(q); return 0; }
//get the next flow and the next packet without deleting them from heap //return the next packet to transmit from virtual heap Packet* showNextPacketToTransmit(bool virtual_f) { Packet* p = NULL; Flow* flow; FHeap* heap = virtual_f ? virtual_flows : flows; if (heap->count == 0) return NULL; flow = heap_front(heap); if (flow == NULL) return NULL; p = (Packet*)queue_front(flow->packets); return p; }
void ast_to_code_gen( queue fifo , FILE* file) { ast current = queue_front(fifo); char* function = current-> left-> node_name; ast move_param = current-> right-> left; if (strcmp(function , "line_width") == 0) { fprintf(file, "\tcairo_set_line_width (cr, %d);\n", current-> right-> node_value); queue_pop(fifo); ast_to_code_gen(fifo, file); } else if (strcmp(function , "line_color") == 0) { float r = move_param-> node_value/100.0; float g = current-> right-> right-> left-> node_value/100.0; float b = current-> right-> right-> right-> node_value/100.0; fprintf(file, "\tcairo_set_source_rgb (cr, %f, %f, %f);\n", r , g , b); queue_pop(fifo); ast_to_code_gen(fifo, file); } else { if (strcmp(current-> right-> node_name , "image") == 0) { queue_pop(fifo); ast_to_code_gen(fifo, file); } else { int x = move_param-> left-> node_value; int y = move_param-> right-> node_value; fprintf(file , "\tcairo_move_to(cr , %d , %d);\n" , x , y); if (current-> right-> right != NULL) ast_to_code_aux(current-> right-> right, file); if (strcmp(function , "draw") == 0) fprintf(file , "\tcairo_stroke(cr);\n"); else fprintf(file , "\tcairo_fill(cr);\n"); queue_pop(fifo); if (!queue_empty(fifo)) ast_to_code_gen(fifo, file); } } }
void *queue_front(queue_t *q){ // NULL-check the parameter and check the size if (!q || (q->size == 0)) return NULL; // if the out stack has items in it, we simply peek if (stack_size(&(q->out)) > 0) return stack_peek(&(q->out)); // otherwise we must dequeue everything from the in // stack to the out stack and then peek int inSize = stack_size(&(q->in)); int i; for (i = 0; i < inSize; i++) stack_push(&(q->out), stack_pop(&(q->in))); return queue_front(q); }
int user_write(t_server *server, t_client *cl) { ssize_t wsize; ssize_t msglen; char *msg; msg = queue_front(cl->queue); msglen = strlen(msg); if ((wsize = write(cl->fd, msg, msglen)) <= 0) { perror(""); return (disconnect_user(server, cl)); } if (wsize < msglen) shift_msg(msg, wsize); else queue_pop(&cl->queue); return (0); }
int main() { // initialize queue_t testQ; queue_init(&testQ); // add some items queue_enqueue(&testQ, "item 1"); queue_enqueue(&testQ, "item 2"); queue_enqueue(&testQ, "item 3"); // print the queue queue_print(&testQ); // dequeue queue_dequeue(&testQ); // print the queue printf("After dequeueing once:\n"); queue_print(&testQ); printf("The size of the queue: %d\n", queue_size(&testQ)); // the front of the queue printf("The front of the queue: %s\n", (char *)queue_front(&testQ)); // the back of the queue printf("The back of the queue: %s\n", (char *)queue_back(&testQ)); // add some more items queue_enqueue(&testQ, "item4"); queue_enqueue(&testQ, "item5"); printf("After queueing twice more:\n"); queue_print(&testQ); // free up the queue's memory queue_destroy(&testQ); return 0; }
void bfs(bst *tree) { int *error = (int*)malloc(sizeof(int)); Queue* q = queue_new(); if(tree->root == NULL) return; else { enqueue(q,tree->root->data); while(queue_size(q)!=0) { int val = queue_front(q,error); node *temp = findNode(tree,val); if(temp->left!=NULL) enqueue(q,temp->left->data); if(temp->right!=NULL) enqueue(q,temp->right->data); print("%d ",val); } } }
void leverl_order_traversl(node *root) { struct queue* q = NULL; q = queue_new(); queue_add_element(q,root); while(!check_empty_queue(q)) { node *currentNode = queue_front(q)->tnode; printf("%d ",currentNode->value); queue_remove_element(q); if (currentNode->left) { queue_add_element(q,currentNode->left); } if(currentNode->right) { queue_add_element(q,currentNode->right); } } queue_free(q); /* always remember to free() the malloc()ed memory */ free(q); /* free() if queue is kept separate from free()ing the structure, I think its a good design */ q = NULL; /* after free() always set that pointer to NULL, C will run havon on you if you try to use a dangling pointer */ }
int main() { TQueue queue; TInfo info; int select, capacity; printf("Inserisci la dimensione della coda! \n"); scanf("%d", &capacity); queue=queue_create(capacity); select=menu(); while (select>=1 && select<=4) { switch (select) { case 1: if(!queue_is_full(&queue)){ info=ReadInfo(); queue_add(&queue, info); } else{ printf("La coda è piena! \n"); } select=menu(); break; case 2: if(!queue_is_empty(&queue)){ info=queue_front(&queue); printf("\n Prossimo cliente:\n"); PrintInfo(&info); } else{ printf("La coda è vuota! \n"); } select=menu(); break; case 3: if(!queue_is_empty(&queue)){ info=queue_remove(&queue); printf("\n Stai servendo il cliente:\n"); PrintInfo(&info); } else{ printf("La coda è vuota! \n"); } select=menu(); break; case 4: queue_destroy(&queue); printf("Programma chiuso correttamente! \n"); select=0; break; } } return 0; }
int main (int argc, char* argv[]) { queue p=queue_create(); int a=1, b=2, c=3; printf("push %d\n", a); queue_push(p, &a); printf("push %d\n", b); queue_push(p, &b); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); printf("push %d\n", c); queue_push(p, &c); void * front = queue_front(p); printf("front = %d\n", *((int*)front)); // = 1 printf("pop\n"); queue_pop(p); front = queue_front(p); printf("front = %d\n", *((int*)front)); // = 2 printf("pop\n"); queue_pop(p); front = queue_front(p); printf("front = %d\n", *((int*)front)); // = 3 printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); printf("pop\n"); queue_pop(p); queue_destroy(p); return 0; }
int queuetest(int nargs, char** args) { (void)nargs; (void)args; print("Beginning queue test...\n"); struct queue* newqueue; newqueue = queue_create(); assert(newqueue != NULL); assert(queue_getsize(newqueue) == 0); assert(queue_isempty(newqueue)); queue_assertvalid(newqueue); int i; int* elem; /* push back TESTSIZE number of elements */ for (i = 0; i < TESTSIZE; ++i) { elem = (int*)kmalloc(sizeof(int)); assert(elem != NULL); *elem = i; /* check for ENOMEM */ assert(queue_push(newqueue, (void*) elem) == 0); } assert(queue_getsize(newqueue) == TESTSIZE); assert(!queue_isempty(newqueue)); queue_assertvalid(newqueue); /* pop front TESTSIZE number of elements */ for (i = 0; i < TESTSIZE; ++i) { elem = (int*)queue_front(newqueue); assert(*elem == i); queue_pop(newqueue); kfree(elem); } assert(queue_getsize(newqueue) == 0); assert(queue_isempty(newqueue)); queue_assertvalid(newqueue); /* REPEAT to test if the queue is reusable */ /* push back TESTSIZE number of elements */ for (i = 0; i < TESTSIZE; ++i) { elem = (int*)kmalloc(sizeof(int)); assert(elem != NULL); *elem = i; /* check for ENOMEM */ assert(queue_push(newqueue, (void*) elem) == 0); } assert(queue_getsize(newqueue) == TESTSIZE); assert(!queue_isempty(newqueue)); queue_assertvalid(newqueue); /* pop front TESTSIZE number of elements */ for (i = 0; i < TESTSIZE; ++i) { elem = (int*)queue_front(newqueue); assert(*elem == i); queue_pop(newqueue); kfree(elem); } assert(queue_getsize(newqueue) == 0); assert(queue_isempty(newqueue)); queue_assertvalid(newqueue); queue_destroy(newqueue); print("queue test complete\n"); return 0; }
static int video_write(GstBaseSink *sink, GstDVBVideoSink *self, GstBuffer *buffer, size_t start, size_t end) { size_t written = start; size_t len = end; struct pollfd pfd[2]; pfd[0].fd = self->unlockfd[0]; pfd[0].events = POLLIN; pfd[1].fd = self->fd; pfd[1].events = POLLOUT | POLLPRI; do { if (self->flushing) { GST_DEBUG_OBJECT(self, "flushing, skip %d bytes", len - written); break; } else if (self->paused || self->unlocking) { GST_OBJECT_LOCK(self); queue_push(&self->queue, buffer, written, end); GST_OBJECT_UNLOCK(self); GST_DEBUG_OBJECT(self, "pushed %d bytes to queue", len - written); break; } else { GST_LOG_OBJECT (self, "going into poll, have %d bytes to write", len - written); } if (poll(pfd, 2, -1) < 0) { if (errno == EINTR) continue; return -1; } if (pfd[0].revents & POLLIN) { /* read all stop commands */ while (1) { gchar command; int res = read(self->unlockfd[0], &command, 1); if (res < 0) { GST_DEBUG_OBJECT (self, "no more commands"); /* no more commands */ break; } } } if (pfd[1].revents & POLLPRI) { GstStructure *s; GstMessage *msg; struct video_event evt; if (ioctl(self->fd, VIDEO_GET_EVENT, &evt) < 0) { g_warning("failed to ioctl VIDEO_GET_EVENT!"); } else { GST_INFO_OBJECT (self, "VIDEO_EVENT %d", evt.type); if (evt.type == VIDEO_EVENT_SIZE_CHANGED) { s = gst_structure_new ("eventSizeChanged", "aspect_ratio", G_TYPE_INT, evt.u.size.aspect_ratio == 0 ? 2 : 3, "width", G_TYPE_INT, evt.u.size.w, "height", G_TYPE_INT, evt.u.size.h, NULL); msg = gst_message_new_element (GST_OBJECT(sink), s); gst_element_post_message (GST_ELEMENT(sink), msg); } else if (evt.type == VIDEO_EVENT_FRAME_RATE_CHANGED) { s = gst_structure_new ("eventFrameRateChanged", "frame_rate", G_TYPE_INT, evt.u.frame_rate, NULL); msg = gst_message_new_element (GST_OBJECT(sink), s); gst_element_post_message (GST_ELEMENT(sink), msg); } else if (evt.type == 16 /*VIDEO_EVENT_PROGRESSIVE_CHANGED*/) { s = gst_structure_new ("eventProgressiveChanged", "progressive", G_TYPE_INT, evt.u.frame_rate, NULL); msg = gst_message_new_element (GST_OBJECT(sink), s); gst_element_post_message (GST_ELEMENT(sink), msg); } else { g_warning ("unhandled DVBAPI Video Event %d", evt.type); } } } if (pfd[1].revents & POLLOUT) { size_t queuestart, queueend; GstBuffer *queuebuffer; GST_OBJECT_LOCK(self); if (queue_front(&self->queue, &queuebuffer, &queuestart, &queueend) >= 0) { int wr = write(self->fd, GST_BUFFER_DATA(queuebuffer) + queuestart, queueend - queuestart); if (wr < 0) { switch (errno) { case EINTR: case EAGAIN: break; default: GST_OBJECT_UNLOCK(self); return -3; } } else if (wr >= queueend - queuestart) { queue_pop(&self->queue); GST_DEBUG_OBJECT (self, "written %d queue bytes... pop entry", wr); } else { self->queue->start += wr; GST_DEBUG_OBJECT (self, "written %d queue bytes... update offset", wr); } GST_OBJECT_UNLOCK(self); continue; } GST_OBJECT_UNLOCK(self); int wr = write(self->fd, GST_BUFFER_DATA(buffer) + written, len - written); if (wr < 0) { switch (errno) { case EINTR: case EAGAIN: continue; default: return -3; } } written += wr; } } while (written < len); return 0; }
/// @brief Main function to test the queue structure /// /// @return 0 if all went ok, 1 otherwise int main(void) { queue* s = NULL; int count = 100000; printf("\033[33m > Starting queue test\033[37m :\n\n"); // Creating queue printf("[ \033[32mCreating\033[37m queue ..\n"); s = queue_create(); if (!s) return 1; printf("Queue correctly created ] \n\n"); printf("Is the queue empty ? > %s\n", (queue_empty(s) ? "yes" : "no")); printf("Queue size : %i\n\n", queue_size(s)); // Pushing / Poping printf("[ \033[32mPushing\033[37m %i elements in the queue ..\n\n", count); for (int i = 0; i < count; i++) queue_push(s, i); printf("Is the queue empty ? > %s\n", (queue_empty(s) ? "yes" : "no")); printf("Queue size : %i\n\n", queue_size(s)); printf("[ \033[32mPoping\033[37m %i elements from the queue ..\n\n", count); for (int i = 0; i < count; i++) queue_pop(s); printf("Is the queue empty ? > %s\n", (queue_empty(s) ? "yes" : "no")); printf("Queue size : %i\n\n", queue_size(s)); printf("[ \033[32mPushing\033[37m 100000 elements in the queue ..\n\n"); for (int i = 0; i < count; i++) queue_push(s, i); printf("Is the queue empty ? > %s\n", (queue_empty(s) ? "yes" : "no")); printf("Queue size : %i\n\n", queue_size(s)); printf("[ \033[32mClearing\033[37m the queue ..\n\n"); queue_clear(s, NULL); printf("Is the queue empty ? > %s\n", (queue_empty(s) ? "yes" : "no")); printf("Queue size : %i\n\n", queue_size(s)); printf("[ \033[32mPushing\033[37m 1, 2, 3, 4, 5 in the queue ..\n\n"); queue_push(s, 1); queue_push(s, 2); queue_push(s, 3); queue_push(s, 4); queue_push(s, 5); printf("\033[32mFront\033[37m element is : %i\n", queue_front(s)); printf("\033[32mBack\033[37m element is : %i\n\n", queue_back(s)); printf("\033[32mVisiting\033[37m the queue ..\n"); queue_visit(s, visitor, NULL); printf("\n[ \033[32mDeleting\033[37m the queue..\n\n"); queue_delete(s, NULL); printf("Is the queue empty ? > %s\n", (queue_empty(s) ? "yes" : "no")); printf("Queue size : %i\n\n", queue_size(s)); return 0; }
void dancepartners(cir_queue femaledancer, cir_queue maledancer, int lun)//舞伴配对函数 { int m = length_queue(&femaledancer); //计算女队人数 int n = length_queue(&maledancer); //计算男队人数 for (int j = 1; j <= lun; ++j) //for循环表示舞会进行的轮数情况 {//通过对男女队人数的比较,进行一下操作 if (m>n)// 女队人数多于男队,女队有剩余队员 { person_type p; person_type q; person_type s; printf("------------------------"); printf("第%d轮配对情况:\n", j); for (int i = 1; i <= n; ++i) //for循环实现配对操作 { p = de_queue(&maledancer); q = de_queue(&femaledancer); //出队的男女舞伴 printf("男:%s", p.name); printf("和女:%s配对成功\n", q.name);//输出配对情况 en_queue(&maledancer, p); en_queue(&femaledancer, q); //将出队的男女舞伴重新进队 } //输出女队剩余队员情况,并输出在下一轮首先出场的队员姓名 printf("女队中还有%d个人在等待!\n", m - n); s = queue_front(&femaledancer); printf("女队中第一个等待的是:%s\n", s.name); } else if (m<n) //男队人数多于女队,男队有剩余队员 { person_type p; person_type q; person_type s; printf("------------------------"); printf("第%d轮配对情况:\n", j); for (int i = 1; i <= m; ++i) { p = de_queue(&maledancer); q = de_queue(&femaledancer);//出队的男女舞伴 printf("男:%s", p.name); printf("和女:%s配对成功\n", q.name);//输出配对情况 en_queue(&maledancer, p); en_queue(&femaledancer, q); //将出队的男女舞伴重新进队 } //输出男队剩余队员情况,并输出在下一轮首先出场的队员姓名 printf("男队中还有%d个人在等待!\n", n - m); s = queue_front(&maledancer); printf("男队中第一个等待的是:%s\n", s.name); } else //男女队人数相等,没有剩余队员 { person_type p; person_type q; // person_type s; printf("------------------------"); printf("第%d轮配对情况:\n", j); for (int i = 1; i <= m; ++i) { p = de_queue(&maledancer); q = de_queue(&femaledancer); //出队的男女舞伴 printf("男:%s", p.name); printf("和女:%s配对成功\n", q.name);//输出配对情况 en_queue(&maledancer, p); en_queue(&femaledancer, q);//将出队的男女舞伴重新进队 } printf("没有人剩余!\n"); } } }