include/wvbuf.h

/* -*- Mode: C++ -*-
 * Worldvisions Weaver Software:
 *   Copyright (C) 1997-2002 Net Integration Technologies, Inc.
 *
 * Specializations of the generic buffering API and a few new buffers.
 */
#ifndef __WVBUFFER_H
#define __WVBUFFER_H
 
#include "wvstring.h"
#include "wvbufbase.h"
 
/***** Specialization for 'unsigned char' buffers *****/

template <>
class WvBufBase<unsigned char> :
    public WvBufBaseCommonImpl<unsigned char>
{
public:
    explicit WvBufBase(WvBufStore *store) :
        WvBufBaseCommonImpl<unsigned char>(store) { }

    void putstr(WvStringParm str);
    void putstr(WVSTRING_FORMAT_DECL)
        { putstr(WvString(WVSTRING_FORMAT_CALL)); }

    WvString getstr();

    WvString getstr(size_t len);
 
    /*** Get/put characters as integer values ***/

    int getch()
        { return int(get()); }

    void putch(int ch)
        { put((unsigned char)ch); }

    int peekch(int offset = 0)
        { return int(peek(offset)); }
    
    size_t strchr(int ch);

    size_t match(const void *bytelist, size_t numbytes)
        { return _match(bytelist, numbytes, false); }
        
    size_t match(const char *chlist)
        { return match(chlist, strlen(chlist)); }

    size_t notmatch(const void *bytelist, size_t numbytes)
        { return _match(bytelist, numbytes, true); }

    size_t notmatch(const char *chlist)
        { return notmatch(chlist, strlen(chlist)); }
 
    /*** Overload put() and move() to accept void pointers ***/
    
    void put(unsigned char value)
        { WvBufBaseCommonImpl<unsigned char>::put(value); }
    void put(const void *data, size_t count)
        { WvBufBaseCommonImpl<unsigned char>::put(
            (const unsigned char*)data, count); }
    void move(void *data, size_t count)
        { WvBufBaseCommonImpl<unsigned char>::move(
            (unsigned char*)data, count); }
    void poke(void *data, int offset, size_t count)
        { WvBufBaseCommonImpl<unsigned char>::poke(
            (unsigned char*)data, offset, count); }
 
private:
    // moved here to avoid ambiguities between the match variants
    size_t _match(const void *bytelist, size_t numbytes, bool reverse);
};
 
 
 
/***** Declarations for some commonly used memory buffers *****/

class WvInPlaceBuf : public WvInPlaceBufBase<unsigned char>
{
public:
    WvInPlaceBuf(void *_data, size_t _avail, size_t _size,
        bool _autofree = false) :
        WvInPlaceBufBase<unsigned char>((unsigned char*)_data,
            _avail, _size, _autofree) { }
    explicit WvInPlaceBuf(size_t _size) :
        WvInPlaceBufBase<unsigned char>(_size) { }
    WvInPlaceBuf() :
        WvInPlaceBufBase<unsigned char>() { }
    void reset(void *_data, size_t _avail, size_t _size,
        bool _autofree = false)
    {
        WvInPlaceBufBase<unsigned char>::reset(
            (unsigned char*)_data, _avail, _size, _autofree);
    }
};

class WvConstInPlaceBuf : public WvConstInPlaceBufBase<unsigned char>
{
public:
    WvConstInPlaceBuf(const void *_data, size_t _avail) :
        WvConstInPlaceBufBase<unsigned char>(
            (const unsigned char*)_data, _avail) { }
    WvConstInPlaceBuf() :
        WvConstInPlaceBufBase<unsigned char>() { }
    void reset(const void *_data, size_t _avail)
    {
        WvConstInPlaceBufBase<unsigned char>::reset(
            (const unsigned char*)_data, _avail);
    }
};

class WvCircularBuf : public WvCircularBufBase<unsigned char>
{
public:
    WvCircularBuf(void *_data, size_t _avail, size_t _size,
        bool _autofree = false) :
        WvCircularBufBase<unsigned char>((unsigned char*)_data,
            _avail, _size, _autofree) { }
    explicit WvCircularBuf(size_t _size) :
        WvCircularBufBase<unsigned char>(_size) { }
    WvCircularBuf() :
        WvCircularBufBase<unsigned char>() { }
    void reset(void *_data, size_t _avail, size_t _size,
        bool _autofree = false)
    {
        WvCircularBufBase<unsigned char>::reset(
            (unsigned char*)_data, _avail, _size, _autofree);
    }
};

typedef WvBufBase<unsigned char> WvBuf;

typedef WvDynBufBase<unsigned char> WvDynBuf;

typedef WvNullBufBase<unsigned char> WvNullBuf;

typedef WvBufCursorBase<unsigned char> WvBufCursor;

typedef WvBufViewBase<unsigned char> WvBufView;

class WvConstStringBuffer : public WvConstInPlaceBuf
{
    WvString xstr;
 
public:
    explicit WvConstStringBuffer(WvStringParm _str);

    WvConstStringBuffer();

    void reset(WvStringParm _str);

    WvString str()
        { return xstr; }
};
 
#endif // __WVBUFFER_H