Beesnest/DcBuffer.cpp

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Beesnest is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

/**
 * CdcBuffer.cpp: implementation of the CdcBuffer class.
 * for documentation see the header file.
 */

#include "DcBuffer.h"

CdcBuffer::CdcBuffer()
: aBuffer (NULL), nSize (0), nGrow (DEFAULT_SIZE), nDataSize (0),
    pRefCount (new int (1)), pMutex (new CdcMutex ())
{ }


CdcBuffer::CdcBuffer (unsigned int size, int grow) throw (CdcException)
: aBuffer (NULL), nSize (0), nGrow (grow), nDataSize (0),
    pRefCount (new int (1)), pMutex (new CdcMutex ())
{
    PreperRoom (size);
}


void CdcBuffer::PreperRoom (int size) throw (CdcException)
{
    bool ref_copy = false;
    bool increase_space = false;
    /* Lock the object. */
    pMutex->Lock ();
    /* Check if need to create another object because Copy On Write. */
    if (*pRefCount > 1)
    {
        --(*pRefCount);
        pRefCount = new int (1);
        ref_copy = true;
    }
    /* Check if need to increase the space in the buffer. */
    if (nSize < nDataSize + size)
    {
        increase_space = true;
        /* Find how many 'grow' units need to add. */
        if (nGrow < 1) nGrow = DEFAULT_SIZE;
        int factor = (((nDataSize + size) - nSize) / nGrow) + 1;
        nSize += factor * nGrow;
    }
    /* If one of the conditions are true. */
    if (increase_space || ref_copy)
    {
        /* allocate new space. */
        t_buff_unit* temp = new t_buff_unit [nSize];
        if (temp == NULL)
        {   /* This "complected" section is in case of allocation error. */
            pMutex->Unlock ();
            if (ref_copy == true)
            {
                aBuffer = NULL;
                pMutex = NULL;
            }
            throw (CdcException ("Out of memory!"));
        }
        /* Copy the first part of the buffer. */
        memcpy (temp, aBuffer, nDataSize);
        /* Delete old buffer if no other object points to it. */
        if (!ref_copy && aBuffer != NULL)
            delete aBuffer;
        /* Point to new buffer. */
        aBuffer = temp;
    }
    /* Unlock the object and make a new Mutex if needed. */
    pMutex->Unlock ();
    if (ref_copy)
        pMutex = new CdcMutex ();
}


void CdcBuffer::Attach (const CdcBuffer& buff)
{
    /* Lock the object. */
    buff.pMutex->Lock ();
    /* Copy values. */
    aBuffer = buff.aBuffer;
    pRefCount = buff.pRefCount;
    nDataSize = buff.nDataSize;
    nSize = buff.nSize;
    nGrow = buff.nGrow;
    pMutex = buff.pMutex;
    /* Increase reference. */
    (*pRefCount)++;
    /* Unlock object. */
    buff.pMutex->Unlock ();
}


void CdcBuffer::Detach ()
{
    /* Lock the object. */
    pMutex->Lock ();
    /* Decrease reference counter and delete buffer if needed. */
    if (--(*pRefCount) == 0)
    {
        if (aBuffer != NULL)
        {
            delete aBuffer;
            aBuffer = NULL;
        }
        if (pRefCount != NULL)
        {
            delete pRefCount;
            pRefCount = NULL;
        }
        /* Deletion of the Mutex will unlock it. */
        delete pMutex;
    }
    else
        pMutex->Unlock ();
}


const CdcBuffer& CdcBuffer::operator = (const CdcBuffer& buff)
{
    if (aBuffer != buff.aBuffer)
    {
        Detach ();
        Attach (buff);
    }

    return *this;
}


t_buff_unit CdcBuffer::operator[] (int index) const throw (CdcException)
{
    if (index < 0 || index >= nDataSize)
        throw (CdcException ("Index out of bounds!"));

    return aBuffer [index];
}


CdcBuffer& CdcBuffer::Append (const t_buff_unit data) throw (CdcException)
{
    PreperRoom (1);
    aBuffer [nDataSize++] = data;
    return *this;
}

CdcBuffer& CdcBuffer::Append (CdcString& data) throw (CdcException)
{
    PreperRoom (data.GetLength ());
    memcpy (aBuffer + nDataSize, data.GetBuffer (),
        data.GetLength ());
    nDataSize += data.GetLength ();
    return *this;
}

CdcBuffer& CdcBuffer::Append (const CdcBuffer& data) throw (CdcException)
{
    PreperRoom (data.nDataSize);
    memcpy (aBuffer + nDataSize, data.aBuffer, data.nDataSize);
    nDataSize += data.nDataSize;
    return *this;
}

CdcBuffer& CdcBuffer::Append (int data) throw (CdcException)
{
    char temp [15];
    sprintf (temp, "%d", data);
    Append (temp);
    return *this;
}

CdcBuffer& CdcBuffer::Append (const t_buff_unit* data,
                              int length) throw (CdcException)
{
    if (length < 0)
        length = strlen (data);

    PreperRoom (length);
    memcpy (aBuffer + nDataSize, data, length);
    nDataSize += length;
    return *this;
}


int CdcBuffer::GetSize () const
{
    return nSize;
}

int CdcBuffer::GetDataSize () const
{
    return nDataSize;
}

t_buff_unit* CdcBuffer::GetPointer () const
{
    return aBuffer;
}

/* This function works with the brute-force algorithm for now... */
int CdcBuffer::Find (const char* str, int start, int stop) const
{
    if (str == NULL) return -1;
    if (start >= nDataSize) return -1;
    if (stop == 0) stop = nDataSize;
    char* pbuf = aBuffer + start;
    int str_leng = strlen (str), i;

    while (pbuf - aBuffer <= stop - str_leng)
    {
        i = 0;
        while (pbuf[i] == str[i])
            if (++i == str_leng)
                return pbuf - aBuffer;
        pbuf++;
    }

    return -1;
}


int CdcBuffer::Find (char chr, int start, int stop) const
{
    if (start >= nDataSize) return -1;
    if (stop == 0) stop = nDataSize;
    char* pbuf = aBuffer + start;

    while (pbuf - aBuffer < stop)
        if (*pbuf == chr)
            return pbuf - aBuffer;
        else
            ++pbuf;

    return -1;
}


int CdcBuffer::ReplaceAll (const char* strold, const char* strnew,
                           int stroldlen, int strnewlen,
                           int start, int stop)
{
    if (strold == NULL) return 0;
    int count = 1;
    int list [100]; /* cannot make more then 100 replaces. */
    /* Deal with the lengths of strings. */
    if (stroldlen < 0)
        stroldlen = strlen (strold);
    if (strnewlen < 0)
        strnewlen = strlen (strnew);
    /* Make list of place to replace (temp is for string without NULL). */
    CdcString temp (strold, stroldlen);
    list[0] = Find (temp, start, stop);
    if (list[0] == -1) return 0;
    while ((list[count] = Find (temp, list [count - 1] + 1, stop)) != -1)
    {
        ++count;
        if (count == 100) return 0;
    }
    /* Find how much to enlarge the buffer. We want to call PreperRoom
        even if size-gap is zero or negetive.*/
    int i, size_gap = (strnewlen - stroldlen);
    PreperRoom (size_gap * count);
    /* Move the parts we want to save to make room to the new strings. */
    for (i = 0; i < count; ++i)
        memmove (aBuffer + list[i] + (size_gap * i) + strnewlen,
                 aBuffer + list[i] + (size_gap * i) + stroldlen,
                 nDataSize - (list[i] + stroldlen));
    /* Copy the new string to the new rooms. */
    for (i = 0; i < count; ++i)
        memcpy (aBuffer + list[i] + (size_gap * i),
                strnew, strnewlen);

    nDataSize += (size_gap * count);
    return count;
}


int CdcBuffer::ReplaceAll (char old_chr, char new_chr)
{
    /* Copy the buffer if there is more then one reference. */
    PreperRoom (0);
    int place = -1, count = 0;

    while ((place = Find (old_chr, place + 1)) != -1)
    {
        aBuffer [place] = new_chr;
        ++ count;
    }

    return count;
}


bool CdcBuffer::IsWhiteSpaces (int start, int stop)
{
    if (start >= nDataSize) return false;
    if (stop == 0) stop = nDataSize;
    if (stop < start) return false;

    for (int i = start; i < stop; ++i)
        if (isspace (aBuffer[i]) == false)
            return false;   /* found non white space. */
    return true;            /* Go to end of scan area. */
}