#pragma once

#include<stdbool.h>

/* 链式栈接口的定义头文件 */

#define true 1

#define false 0

//读写器配置

typedef struct {

    unsigned char data[];   //数据

    unsigned int lenght;   // 有效数据

}Data;

/* 队列的数据类型 */

typedef Data * datatype;

/* 静态链的数据结构 */

typedef struct q_node {

    datatype data;

    struct q_node *next;

}q_node, *link_node;

typedef struct l_queue {

    /* 队头指针 */

    q_node *front;

    /* 队尾指针 */

    q_node *rear;

}*link_queue;

/* 静态顺序链的接口定义 */

/* 静态链的初始化 */

link_queue queue_init();

/* 判断队列是否为空,若为空

* 返回true

* 否则返回false

*/

int queue_empty(link_queue q);

/* 插入元素e为队q的队尾新元素

* 插入成功返回true

* 队满返回false

*/

int queue_en(link_queue q, datatype e);

/* 队头元素出队

* 用e返回出队元素,并返回true

* 若队空返回false

*/

int queue_de(link_queue q, datatype *e);

/* 清空队 */

void queue_clear(link_queue q);

/* 销毁队 */

void queue_destroy(link_queue q);

//判断epcid是否已存在队列中,true在，false不在

bool queue_Contains(link_queue q, unsigned char * data, int lenght);

/* 获得队头元素

* 队列非空,用e返回队头元素,并返回true

* 否则返回false

*/

int get_front(link_queue q, datatype *e);

bool strncmp_Lsg(unsigned char * data, unsigned char * data2, int lenght);

/* 获得队长 */

int queue_len(link_queue q);

/* 遍历队 */

void queue_traverse(link_queue q, void(*visit)(link_queue q));

void visit(link_queue q);

/* 接口的实现文件 */

#include<stdio.h>

#include<stdlib.h>

#include"lsg_queue.h"

#include<string.h>

//一个特殊的队列，出列，并未删除，使用一个线程来按照存在在队列固定时间后删除

link_queue queue_init()

{

    /* 新建头结点 */

    link_node new_node = (link_node)malloc(sizeof(q_node));

    new_node->next = NULL;

    /* 指针结点 */

    link_queue q = (link_queue)malloc(sizeof(*q));

    q->front = q->rear = new_node;

    return q;

}

int queue_empty(link_queue q)

{

    return q->front == q->rear;

}

int queue_en(link_queue q, datatype e)

{

    /* 新建数据结点 */

    link_node new_node = (link_node)malloc(sizeof(q_node));

    /* 内存分配失败 */

    if (!new_node)

        return false;

    new_node->data = e;

    new_node->next = NULL;

    q->rear->next = new_node;

    q->rear = new_node;

    return true;

}

/* 队头元素出队

* 用e返回出队元素,并返回true

* 若队空返回false

*/

int queue_de(link_queue q, datatype * e)

{

    /* 队列为空 */

    if (q->front == q->rear)

        return false;

    *e = q->front->next->data;

    link_node temp = q->front->next;

    q->front->next = temp->next;

    /* 防止丢失尾指针 */

    if (temp == q->rear)

        q->rear = q->front;

    free(temp);

    temp = NULL;

    return true;

}

//判断epcid是否已存在队列中,true在，false不在

bool queue_Contains(link_queue q, unsigned char * data, int lenght)

{

    /* 头结点 */

    link_node head = q->front;

    /* 第一个结点 */

    link_node temp = head->next;

    while (temp)

    {

        //去掉后面的rssi值跟校验位 temp->data->lenght-2 == lenght

        if (strncmp_Lsg(temp->data->data, data, lenght) && temp->data->lenght -  == lenght)

        {

            return true;

        }

        link_node p = temp;

        temp = p->next;

    }

    return false;

}

bool strncmp_Lsg(unsigned char * data, unsigned char * data2, int lenght)

{

    int i;

    for (i = ; i < lenght; i++)

    {

        if (*data != *data2)

        {

            return false;

        }

        data++;

        data2++;

    }

    return true;

}

void queue_clear(link_queue q)

{

    /* 头结点 */

    link_node head = q->front;

    q->front = q->rear = head;

    /* 第一个结点 */

    link_node temp = head->next;

    while (temp)

    {

        link_node p = temp;

        temp = p->next;

        free(p->data);

        free(p);

        p = NULL;

    }

    head->next = NULL;

}

void queue_destroy(link_queue q)

{

    queue_clear(q);

    //清头节点

    free(q->front);

    free(q);

    q = NULL;

}

int get_front(link_queue q, datatype * e)

{

    /* 队为空 */

    if (q->front == q->rear)

        return false;

    *e = q->front->next->data;

    return true;

}

int queue_len(link_queue q)

{

    /* 头结点 */

    link_node p = q->front->next;

    /* 计数器 */

    int count = ;

    while (p)

    {

        count += ;

        p = p->next;

    }

    return count;

}

void queue_traverse(link_queue q, void(*visit)(link_queue q))

{

    visit(q);

}

void visit(link_queue q)

{

    int i;

    /* 头结点 */

    link_node p = q->front->next;

    if (!p)

    {

        printf("队列为空");

    }

    while (p)

    {

        printf("开始输出：");

        for (i = ; i < p->data->lenght; i++)

        {

            printf("%hhu ", p->data->data[i]);

        }

        printf("\n");

        p = p->next;

    }

    printf("\n");

}

#pragma warning(disable:4996)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <conio.h>

#include <windows.h>

#include <winnt.h>

#include"lsg_queue.h"

#define BAUD_RATE 9600

#define p printf

int main(int argc, char *argv[])

{

    char buf[];

    int lenght = , i = ;

    unsigned char datatemp[] = { 0xA0, 0x06, 0x01, 0x74 };

    datatype e = NULL;

    link_queue q = queue_init();

    Data * data = (struct Data*)malloc(sizeof(Data));/*2.结构体指针需要初始化*/

    Data * data2 = (struct Data*)malloc(sizeof(Data));/*2.结构体指针需要初始化*/

    data->lenght = ;

    data2->lenght = ;

    for (i = ; i < data->lenght; i++)

    {

        data->data[i] = datatemp[i];

        data2->data[i] = datatemp[i];

    }

    printf("加入队列");

    queue_en(q, data);

    queue_en(q, data);

    printf("length=%d\n", queue_len(q));

    if (strncmp_Lsg(&datatemp[], &datatemp[], ))

    {

        p("\n测试成功已存在");

    }

    datatemp[] = ;

    if (queue_Contains(q, datatemp, data->lenght))

    {

        p("已存在");

    }

    queue_de(q, &e);

    for (i = ; i < e->lenght; i++)

    {

        p("%hhu ", e->data[i]);

    }

    queue_traverse(q, visit);

    queue_destroy(q);

    printf("退出");

    getchar();

    system("pause");

    return ;

}