#ifndef FIFO_BUFFER_H_

#define FIFO_BUFFER_H_

#include <stdint.h>

class FifoBuffer

{

public:

    enum

    {

        enmDefaultBufferLen = ,

    };

public:

    FifoBuffer(const uint32_t size = enmDefaultBufferLen);

    ~FifoBuffer();

public:

    uint32_t Put(const char *buf, const uint32_t bufLen);

    uint32_t Get(char buf[], const uint32_t maxBufLen);

    uint32_t Size(){ return size; }

    uint32_t EmptySize();

    uint32_t UsedSize();

    const char *Buffer(){ return buffer; }

private:

    uint32_t Min(uint32_t left, uint32_t right){ return left > right ? right : left; }

private:

    uint32_t size;

    volatile uint32_t in;

    volatile uint32_t out;

    char *buffer;

};

#endif

#include <malloc.h>

#include <new>

#include <algorithm>

#include "fifo_buffer.h"

//////////////////////////////////////////////////////////////////////////

// when out < in

// |                                        |

// |----------------------------------------|

// 0       out|~~~~~~~~~~|in                size

//////////////////////////////////////////////////////////////////////////

// when out > in

// |                                        |

// |----------------------------------------|

// 0~~~~~~~|in        out|~~~~~~~~~~~~~~~~~~size

//////////////////////////////////////////////////////////////////////////

FifoBuffer::FifoBuffer(const uint32_t size /*= enmDefaultBufferLen*/) :in(), out(), size()

{

    buffer = new (std::nothrow) char[size];

    if (!buffer){ return; }

    memset(buffer, , size);

    this->size = size;

}

FifoBuffer::~FifoBuffer()

{

    if (buffer)

    {

        delete[] buffer;

    }

}

uint32_t FifoBuffer::Put(const char *buf, const uint32_t bufLen)

{

    uint32_t lengthToPut = Min(bufLen, EmptySize());

    /* first put the data starting from fifo->in to buffer end */

    uint32_t len = Min(lengthToPut, size - (in % size));

    memcpy(buffer + (in % size), buf, len);

    /* then put the rest (if any) at the beginning of the buffer */

    memcpy(buffer, buf + len, lengthToPut - len);

    in += lengthToPut;

    return lengthToPut;

}

uint32_t FifoBuffer::Get(char buf[], const uint32_t maxBufLen)

{

    uint32_t lengthToGet = Min(maxBufLen, UsedSize());

    /* first get the data from fifo->out until the end of the buffer */

    uint32_t len = Min(lengthToGet, size - (out % size));

    memcpy(buf, buffer + (out % size), len);

    /* then get the rest (if any) from the beginning of the buffer */

    memcpy(buf + len, buffer, lengthToGet - len);

    out += lengthToGet;

    return lengthToGet;

}

uint32_t FifoBuffer::EmptySize()

{

    return size - in + out;

}

uint32_t FifoBuffer::UsedSize()

{

    return in - out;

}

#include <stdio.h>

#include <fstream>

#include <windows.h>

#include <thread>

#include "fifo_buffer.h"

const char *fileName = "data.txt";

enum

{

    enummaxBufLen = ,

};

void WriteToFile(const char *fileName, const char *buf, const uint32_t bufLen);

void ReadFromFile(const char *fileName, char buf[], const uint32_t maxBufLen);

void GenTestFile();

void PutSomeBytes(const char *oriBuf, const uint32_t bufLen, FifoBuffer &fifoBuf);

void GetSomeBytes(FifoBuffer &fifoBuf, char buf[], const uint32_t maxBufLen);

int32_t main()

{

    GenTestFile();

    FifoBuffer fifoBuf(enummaxBufLen + );

    char *oriBuf = new char[enummaxBufLen + ];

    char *putBuf = new char[enummaxBufLen + ];

    memset(oriBuf, , enummaxBufLen + );

    memset(putBuf, , enummaxBufLen + );

    ReadFromFile(fileName, oriBuf, enummaxBufLen);

    //////////////////////////////////////////////////////////////////////////

    std::thread put(PutSomeBytes, oriBuf, enummaxBufLen, std::ref(fifoBuf));

    std::thread get(GetSomeBytes, std::ref(fifoBuf), putBuf, enummaxBufLen);

    put.join();

    get.join();

    printf("%s\n%d\n\n", fifoBuf.Buffer(), strlen(fifoBuf.Buffer()));

    printf("%s\n%d\n\n", putBuf, strlen(putBuf));

    system("pause");

}

void WriteToFile(const char *fileName, const char *buf, const uint32_t bufLen)

{

    std::ofstream outFile(fileName, std::ios::out);

    if (!outFile){ return; }

    outFile.write(buf, bufLen);

    outFile.close();

}

void ReadFromFile(const char *fileName, char buf[], const uint32_t maxBufLen)

{

    std::ifstream inFile(fileName, std::ios::in);

    if (!inFile){ return; }

    inFile.read(buf, maxBufLen);

    inFile.close();

}

void GenTestFile()

{

    char *buf = new char[enummaxBufLen];

    for (uint32_t i = ; i < enummaxBufLen; ++i)

    {

        buf[i] = i %  + '';

    }

    WriteToFile(fileName, buf, enummaxBufLen);

    delete[] buf;

}

void PutSomeBytes(const char *oriBuf, const uint32_t bufLen, FifoBuffer &fifoBuf)

{

    static uint32_t offset = ;

    while (offset < bufLen)

    {

        int32_t byteCount = rand() % ;

        offset += fifoBuf.Put(oriBuf + offset, byteCount);

        Sleep();

    }

}

void GetSomeBytes(FifoBuffer &fifoBuf, char buf[], const uint32_t maxBufLen)

{

    static uint32_t offset = ;

    while (offset < maxBufLen)

    {

        int32_t byteCount = rand() % ;

        offset += fifoBuf.Get(buf + offset, byteCount);

    }

}