circularbuffer.cpp

实现了SS7中MTP2层的基本功能

// File Name: CircularBuffer.cpp
///////////////////////////////////////////////////
#include <stdlib.h>
#include <string.h>

#include "CircularBuffer.h"
#include <stdio.h>

CircularBuffer::CircularBuffer(int _size)
        : buffer(NULL), bufferSize(_size), write_pos(0), read_pos(0)
{
    buffer = (unsigned char *)malloc( bufferSize );
    if( buffer == NULL )
    {
        // 
    }

    // pthread_mutex_init() always returns 0
    pthread_mutex_init( & mutex_buffer, NULL ); // use default attributes

    // we may need PTHREAD_MUTEX_RECURSIVE_NP
}

CircularBuffer::~CircularBuffer(void)
{
    if( buffer ) free( buffer );
    
    pthread_mutex_destroy( & mutex_buffer );
}

int CircularBuffer::reSize(int _newBufLen)
{
    // it's better to keep the existing data
    // refuse to shrink the buffer if we have too data

    if( pthread_mutex_lock( & mutex_buffer ) != 0 )
    {
        return -1;
    }

    unsigned char * tmpbuf = (unsigned char *)malloc( _newBufLen );
    int ret = 0;
    if( tmpbuf )
    {
        int dataCount = getStoredBytesNumber();
        if( dataCount <= _newBufLen )
        {
            //  keep original data
            read( tmpbuf, dataCount );

            free( buffer );
            buffer = tmpbuf;
            bufferSize = _newBufLen;
            read_pos = 0;
            write_pos = dataCount;
        }
        else // cannot keep original data, clear all
        {
            bufferSize = _newBufLen;
            free( buffer );
            buffer = tmpbuf;
            read_pos = 0;
            write_pos = 0;
        }
    }
    else
    {
        ret = -1; // failed without any change
    }

    pthread_mutex_unlock( & mutex_buffer );

    return ret;
}

int CircularBuffer::read(unsigned char * _buffer, int _count)
{
    if( pthread_mutex_lock( & mutex_buffer ) != 0 )
    {
        return -1;
    }

    int ret = 0;
    if( write_pos == read_pos )
    {
        ret = -1; // no data
    }
    else if( getStoredBytesNumber() < _count )
    {
        ret = -2; // not enough data
    }
    // now, we have enough data for reading
    else if( write_pos > read_pos )
    {
        memcpy( _buffer, buffer + read_pos, _count );
        read_pos += _count;
    }
    else // write_pos < read_pos
    {
        if( bufferSize - read_pos >= _count )
        {
            memcpy( _buffer, buffer + read_pos, _count );
            read_pos = (read_pos + _count) % bufferSize;
        }
        else
        {
            memcpy( _buffer, buffer + read_pos, bufferSize - read_pos );
            memcpy( _buffer + bufferSize - read_pos, buffer,
                    _count - (bufferSize - read_pos) );
            read_pos = _count - (bufferSize - read_pos);
        }
    }

    pthread_mutex_unlock( & mutex_buffer );

    return ret;
}

int CircularBuffer::write(unsigned char * _buffer, int _count)
{
    if( pthread_mutex_lock( & mutex_buffer ) != 0 )
    {
        return -1;
    }

    int ret = 0;
    if( getFreeBytesNumber() < _count )
    {
        printf( "CircularBuffer::write() -- has not enough free space\n");
        ret = -3; // not enough space
    }
    // now, we have enough space for writting
    else if( write_pos > read_pos )
    {
        if( bufferSize - write_pos >= _count )
        {
            memcpy( buffer + write_pos, _buffer, _count );
            write_pos = (write_pos + _count) % bufferSize;
        }
        else
        {
            memcpy( buffer + write_pos, _buffer, bufferSize - write_pos );
            memcpy( buffer, _buffer + (bufferSize - write_pos), 
                    _count - (bufferSize - write_pos) );
            write_pos = _count - (bufferSize - write_pos);
        }
    }
    else // write_pos =< read_pos
    {
        memcpy( buffer + write_pos, _buffer, _count );
        write_pos += _count;
    }

    pthread_mutex_unlock( & mutex_buffer );

    return ret;
}

// We are NOT using mutex for UT

int CircularBuffer::getFreeBytesNumber()
{
//    if( pthread_mutex_lock( & mutex_buffer ) != 0 )
//    {
//        return -1;
//    }

//    printf( "CircularBuffer::getFreeBytesNumber() -- locked the mutext \n");

    int ret = 0;
    if( write_pos == read_pos )
    {
        ret = bufferSize; // no data
    }
    else if( write_pos > read_pos )
    {
        ret = bufferSize - (write_pos - read_pos);
    }
    else // write_pos < read_pos
    {
        ret = read_pos - write_pos;
    }

//    pthread_mutex_unlock( & mutex_buffer );

//    printf( "CircularBuffer::getFreeBytesNumber() -- unlocked the mutext \n");

//    printf( "CircularBuffer::getFreeBytesNumber() -- write_pos=%d, read_pos=%d, ret=%d\n",
//            write_pos, read_pos, ret );
    return ret;
}

int CircularBuffer::getStoredBytesNumber()
{
//    if( pthread_mutex_lock( & mutex_buffer ) != 0 )
//    {
//        return -1;
//    }

    int ret = 0;
    if( write_pos == read_pos )
    {
        ret = 0; // no data
    }
    else if( write_pos > read_pos )
    {
        ret = write_pos - read_pos;
    }
    else // write_pos < read_pos
    {
        ret = (bufferSize - read_pos) + write_pos;
    }

//    pthread_mutex_unlock( & mutex_buffer );

    return ret;
}


void CircularBuffer::reset()
{
    if( pthread_mutex_lock( & mutex_buffer ) != 0 )
    {
        return;
    }

    write_pos = read_pos = 0;

    pthread_mutex_unlock( & mutex_buffer );
}