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");
}
}
}
