《缓存循环队列的实现》

头文件

/*
 * LanJian_Queue.h
 *
 *  Created on: 2018年9月3日
 *      Author: AnKun
 */

#ifndef SRC_LANJIAN_QUEUE_H_
#define SRC_LANJIAN_QUEUE_H_

#include "stdint.h"
#include "string.h"
#include "stdlib.h"

typedef struct
{
    uint32_t maxsize;           // 队列大小
    uint32_t read;              // 读指针
    uint32_t write;             // 写指针
    uint8_t* payload;           // 指向数据缓存
} Queue_t, *QueuePtr_t;

uint32_t Queue_GetUsed(const QueuePtr_t queue);
uint32_t Queue_GetFree(const QueuePtr_t queue);
int Queue_isFull(const QueuePtr_t queue);
int Queue_isEmpty(const QueuePtr_t queue);
int Queue_Enqueue(QueuePtr_t queue, const void* buf, uint32_t length);
int Queue_Dequeue(QueuePtr_t queue, void* buf, uint32_t len);
void Queue_Init(QueuePtr_t queue, uint32_t maxsize, void* payload);
void Queue_Clear(QueuePtr_t queue);
QueuePtr_t Queue_Create(uint32_t size);
void Queue_Destory(QueuePtr_t queue);

uint32_t Queue_GetUsedEx(uint32_t read, uint32_t write, uint32_t size);
uint32_t Queue_GetFreeEx(uint32_t read, uint32_t write, uint32_t size);
int Queue_EnqueueEx(uint32_t read, uint32_t *write, uint32_t size, void* dst, const void* src, uint32_t length);
int Queue_DequeueEx(uint32_t *read, uint32_t write, uint32_t size, void* dst, const void* src, uint32_t length);

#endif /* SRC_LANJIAN_QUEUE_H_ */

源文件

#include "LanJian_Queue.h"

/**
 * 获得队列使用量
 * @param  queue
 * @return       返回已使用量
 */
uint32_t Queue_GetUsed(const QueuePtr_t queue)
{
    int len = -1;
    len =  queue->write - queue->read;
    if(len >= 0) return len;
    else
        return queue->maxsize + len;
}

uint32_t Queue_GetUsedEx(uint32_t read, uint32_t write, uint32_t size)
{
    int len = -1;
    len =  write - read;
    if(len >= 0) return len;
    else
        return size + len;
}


/**
 * 获得队列空余空间
 * @param  queue
 * @return       队列空余数
 */
uint32_t Queue_GetFree(const QueuePtr_t queue)
{
    return queue->maxsize - Queue_GetUsed(queue) - 1;
}

uint32_t Queue_GetFreeEx(uint32_t read, uint32_t write, uint32_t size)
{
    return size - Queue_GetUsedEx(read, write, size) - 1;
}


/**
 * 检测队列是否满
 * @param  queue
 * @return       1:满    0:不满
 */
int Queue_isFull(const QueuePtr_t queue)
{
    if(queue->read==(queue->write+1)%queue->maxsize)
        return 1;
    else
        return 0;
}

/**
 * 检测队列是否为空
 * @param  queue
 * @return       1:空    0:非空
 */
int Queue_isEmpty(const QueuePtr_t queue)
{
    if(queue->read==queue->write)
        return 1;
    else
        return 0;
}

/**
 * 数据入队
 * @param  queue
 * @param  buf    要入队的数据
 * @param  length 数据长度
 * @return        失败-1, 成功返回入队成功的数量
 */
int Queue_Enqueue(QueuePtr_t queue, const void* buf, uint32_t length)
{
    uint8_t* dataptr = (uint8_t *)buf;
    uint32_t offset = 0;

    if(Queue_GetFree(queue) < length)
        return -1;

    offset = queue->maxsize - queue->write;
    if (offset >= length)
    {
        memcpy(queue->payload + queue->write, dataptr, length);
        queue->write += length;
    }else
    {
        memcpy(queue->payload + queue->write, dataptr, offset);
        memcpy(queue->payload, dataptr + offset, length - offset);
        queue->write = length - offset;
    }
    return length;
}

int Queue_EnqueueEx(uint32_t read, uint32_t *write, uint32_t size, void* dst, const void* src, uint32_t length)
{
    uint8_t* dstptr = (uint8_t *)dst;
    const uint8_t* srcptr = (const uint8_t*)src;
    uint32_t offset = 0;

    if(Queue_GetFreeEx(read, *write, size) < length)
        return -1;

    offset = size - *write;
    if (offset >= length)
    {
        memcpy(dstptr + *write, srcptr, length);
        *write += length;
    }else
    {
        memcpy(dstptr + *write, srcptr, offset);
        memcpy(dstptr, srcptr + offset, length - offset);
        *write = length - offset;
    }
    return length;
}

/**
 * 数据出兑
 * @param  queue
 * @param  buf   存放出队数据的缓存
 * @param  len   出队数据长度
 * @return       失败-1, 成功返回出队字节数
 */
int Queue_Dequeue(QueuePtr_t queue, void* buf, uint32_t len)
{
    uint8_t* dataptr = (uint8_t *)buf;
    uint32_t offset = 0;

    if(Queue_GetUsed(queue) < len)
        return -1;

    offset = queue->maxsize - queue->read;

    if( offset >= len)
    {
        memcpy(dataptr, queue->payload + queue->read, len);
        queue->read += len;
    }else
    {
        memcpy(dataptr, queue->payload + queue->read, offset);
        memcpy(dataptr + offset, queue->payload, len - offset);
        queue->read = len - offset;
    }

    return len;
}

int Queue_DequeueEx(uint32_t *read, uint32_t write, uint32_t size, void* dst, const void* src, uint32_t length)
{
    uint8_t* dstptr = (uint8_t *)dst;
    const uint8_t* srcptr = (const uint8_t *)src;
    uint32_t offset = 0;

    if(Queue_GetUsedEx(*read, write, size) < length)
        return -1;

    offset = size - *read;

    if( offset >= length)
    {
        memcpy(dstptr, srcptr + *read, length);
        *read += length;
    }else
    {
        memcpy(dstptr, srcptr + *read, offset);
        memcpy(dstptr + offset, srcptr, length - offset);
        *read = length - offset;
    }

    return length;
}

/**
 * 初始化一个队列
 * @param queue
 * @param maxsize 队列大小
 * @param payload 队列缓存地址
 */
void Queue_Init(QueuePtr_t queue, uint32_t maxsize, void* payload)
{
    queue->read = 0;
    queue->write = 0;
    queue->payload = (uint8_t* )payload;
    queue->maxsize = maxsize;
}

/**
 * 清理缓存
 * @param queue
 */
void Queue_Clear(QueuePtr_t queue)
{
    queue->read = queue->write;
}

/**
 * 动态创建一个队列
 * @param  size 队列大小
 * @return      成功返回队列对象指针, 失败返回NULL
 */
QueuePtr_t Queue_Create(uint32_t size)
{
    QueuePtr_t queue = NULL;

    queue = (QueuePtr_t)malloc(sizeof(Queue_t));
    if (queue == NULL)
        return NULL;

    queue->maxsize = size;
    queue->read = 0;
    queue->write = 0;

    queue->payload = (uint8_t *)malloc(size);
    if (queue->payload == NULL)
    {
        free(queue);
        return NULL;
    }

    return queue;
}

/**
 * 对于动态创建的队列进行清理工作
 * @param queue
 */
void Queue_Destory(QueuePtr_t queue)
{
    free(queue->payload);
    free(queue);
    queue = NULL;
}

ends…