Subversion Repositories programming

/* Copyright (c) 2005, Ira W. Snyder (devel@irasnyder.com)

 * All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#include "RingBuffer.h"

#include <memory.h>

#include <assert.h>

#include <stdint.h>

/* Constructor -- it should be obvious what it does */

RingBuffer::RingBuffer (int32_t buffer_size)

{

    /* Fire an assert if buffer size is too small.

     * This _is_ safe to remove, since RingBuffer will still work as expected,

     * but you probably made a mistake if you're doing this. */

    assert (buffer_size > 0);

    this->buffer = NULL;

    this->buffer_size = buffer_size;

    buffer = new int8_t[buffer_size];

    r_ptr = buffer;

    w_ptr = buffer;

    buffer_begin = buffer;

    buffer_end = buffer + buffer_size;

    available_bytes = 0;

}

/* Destructor -- cleans up a RingBuffer object.

 * NOTE: If "rb" is your RingBuffer, call "delete rb;" to free it */

RingBuffer::~RingBuffer ()

{

    delete[] buffer;

    buffer = NULL;

    buffer_size = 0;

}

/* Returns the actual number of bytes copied into dst. */

int32_t RingBuffer::read (int8_t *dst, int32_t bytes)

{

    int32_t retVal = 0;

    int32_t nbytes = 0;

    int32_t chkd_bytes = bytes;

    /* Not enough bytes */

    if (chkd_bytes > available_bytes)

    {

        retVal = available_bytes; //we can only return what we have...

        chkd_bytes = available_bytes;

    }

    else /* We've got plenty of data */

    {

        /* Check if we need to wrap */

        if ((r_ptr + chkd_bytes) > buffer_end)

        {

            nbytes = buffer_end - r_ptr; //bytes until the end of the buffer

            /* Copy the bytes from r_ptr to the end of the buffer. */

            memcpy ((void*)dst, (void*)r_ptr, nbytes);

            r_ptr = buffer_begin; //wrap

            /* Copy the remaining bytes */

            memcpy ((void*)(dst+nbytes), (void*)r_ptr, chkd_bytes-nbytes);

            r_ptr += chkd_bytes-nbytes;

        }

        else /* No wrapping needs to happen, copy normally */

        {

            memcpy ((void*)dst, (void*)r_ptr, chkd_bytes);

            r_ptr += chkd_bytes;

        }

        /* Update the number of bytes remaining */

        available_bytes -= chkd_bytes;

        retVal = chkd_bytes;

    }

    return retVal;

}

/* TRUE if we DID NOT loose data

 * FALSE if we DID loose data */

bool RingBuffer::write (int8_t *src, int32_t bytes)

{

    bool retVal = true;

    int32_t  nbytes = 0;

    int8_t *chkd_src = src;    // "checked" source pointer

    int32_t  chkd_bytes = bytes; // "checked" number of bytes

    assert (src != NULL); //make sure src is not null

    assert (chkd_bytes > 0);   //make sure that there are some bytes (safe to disable)

    /* Check if we are going to loose data.

     * Set the return value to FALSE if we will

     * Leave the return value alone otherwise */

    if ((bytes + available_bytes) >= buffer_size)

        retVal = false;

    /* Check if we will "wrap" more than once.

     * Stop this behaivior! */

    if (bytes > buffer_size)

    {

        chkd_src += (bytes-buffer_size); //only the non-overwritten data

        chkd_bytes = buffer_size; //the maximum number of bytes

    }

    /* Check if w_ptr will "cross over" r_ptr.

     * Move r_ptr if necessary to overwrite old bytes */

    if ((w_ptr + chkd_bytes) > r_ptr)

    {

        /* Set the new value of r_ptr */

        r_ptr += (w_ptr + chkd_bytes) - r_ptr;

        /* Check if the new value should have wrapped.

         * Wrap it if necessary. */

        if (r_ptr > buffer_end)

        {

            nbytes = r_ptr - buffer_end;

            r_ptr = buffer_begin + nbytes;

        }

    }

    /* Write data to the buffer.

     * A "wrap" will happen here, so write in two pieces. */

    if ((w_ptr + chkd_bytes) > buffer_end)

    {

        nbytes = buffer_end - w_ptr; //bytes until the end of the buffer

        /* Write the data from w_ptr to the end of the buffer */

        memcpy ((void*)w_ptr, (void*)chkd_src, nbytes);

        w_ptr = buffer_begin; //wrap the w_ptr

        /* Write the rest of the data */

        memcpy ((void*)w_ptr, (void*)(chkd_src+nbytes), chkd_bytes-nbytes);

        w_ptr += chkd_bytes-nbytes;

    }

    else /* No "wrap" will happen, so copy normally */

    {

        memcpy ((void*)w_ptr, (void*)chkd_src, chkd_bytes);

        w_ptr += chkd_bytes;

    }

    /* Add to the bytes stored in the buffer. */

    available_bytes += chkd_bytes;

    /* Since we already wrapped properly, make sure that

     * available_bytes doesn't get too large. */

    if (available_bytes > buffer_size)

        available_bytes = buffer_size;

    return retVal;

}

/* Return the number of bytes available in the buffer. */

int32_t RingBuffer::numBytes()

{

    return available_bytes;

}