buffer.h

// -*- C++ -*-
/*
    $Id: buffer_8h-source.html,v 1.1 2004/10/05 21:11:59 mentat Exp $

    VBuffer Class - Extention of STL vector
    Copyright (C) 1999-2002  Jesse Lovelace <jllovela@eos.ncsu.edu>

    This program 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.

    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef GM_BUFFER_H
#define GM_BUFFER_H

#include <string>
#include <vector>
#include <memory>
#include "gm/misc.h"

namespace GNUMessenger
{
    using namespace std;

    class VBuffer: public vector<byte>
    {
    public:

        VBuffer(): vector<byte>(), m_size(0) {}

        ~VBuffer()
        {
            zero();

            if (m_data.get())
                memset(m_data.get(), 0, m_size * sizeof(byte));
        }

        VBuffer(const string& str):vector<byte>(str.length()) {
            for ( unsigned int i = 0; i < str.length(); i++)
                (*this)[i] = ((byte)str[i]);
        }

        VBuffer(const char * str, unsigned long length):vector<byte>(length)
        {
            for ( unsigned int i = 0; i < length; i++)
                (*this)[i] = ((byte)str[i]);
            
        }

        VBuffer(const VBuffer& buf):vector<byte>()
        {
            reserve(buf.size());
            insert(end(), buf.begin(), buf.end());
        }

        VBuffer(byte * str, unsigned long length):vector<byte>(length)
        {
            for ( unsigned int i = 0; i < length; i++)
                (*this)[i] = (str[i]);
            
        }

        void wipe()
        {
            zero();
            clear();
        }

        const byte * data() const {
            vector<byte>::const_iterator it = begin();

            // zero old buffer data
            if (m_data.get())
                memset(m_data.get(), 0,m_size * sizeof(byte));

            m_size = static_cast<unsigned long>(size());
            m_data.reset( new byte[size()] );

            for (unsigned long i = 0; i < size(); i++)
            {
                m_data[i] = *it;
                it++;
            }

            return m_data.get(); 
        }

        //operator const byte *() const { return data(); }

        VBuffer operator +( const VBuffer& buf)
        {
            VBuffer tmp(*this);
            tmp.insert(tmp.end(), buf.begin(), buf.end());
            return tmp;
        }

        VBuffer& operator =( const VBuffer& buf)
        {
            zero();
            clear();
            reserve(buf.size());

            insert(end(), buf.begin(), buf.end());
            return *this;
        }

        VBuffer& operator += ( const VBuffer& buf )
        {
            reserve(size() + buf.size());
            insert(end(), buf.begin(), buf.end());
            return *this;
        }

        VBuffer& operator += ( const byte& b )
        {
            push_back(b);
            return *this;
        }

        VBuffer sub( unsigned long start, unsigned long length = 0) const
        {
            VBuffer temp;

            unsigned long i;

            if ((start >= size()) || (length > size()))
                return temp;

            if (length == 0)
                temp.reserve(size() - start);
            else
                temp.reserve(length);


            vector<byte>::const_iterator itStart = begin();
            if (start != 0)
                for (i = 0; i < start; i++)
                    itStart++;

            vector<byte>::const_iterator itEnd = itStart;
            if (length == 0)
                itEnd = end();
            else
                for (i = 0; i < length; i++)
                    itEnd++;

            temp.insert(temp.begin(), itStart, itEnd);

            return temp;
        }

    private:

        void zero()
        {
            vector<byte>::iterator it = begin();
            while( it != end() )
            {
                *it=0;
                it++;
            }
        }

        // Temporary byte array and size, mutable
        mutable scoped_array<byte> m_data;
        mutable unsigned long int m_size;

    };

} // !GNUMessenger

#endif // !GM_BUFFER_H

---