http://www.ousob.com --- Legacy Redefined OuSob - File: /wwwroot/clipx/usr/include/wvstreams/wvbufstore.h

/* -*- Mode: C++ -*- * Worldvisions Weaver Software: * Copyright (C) 1997-2002 Net Integration Technologies, Inc. * * Defines basic buffer storage classes. * These are not intended for use directly by clients. * See "wvbufbase.h" for the public API. */ #ifndef __WVBUFFERSTORE_H #define __WVBUFFERSTORE_H #include "wvlinklist.h" #include <assert.h> #include <limits.h> #include <assert.h> /** * This value is used internally to signal unlimited free space. * It is merely meant to be as large as possible yet leave enough * room to accomodate simple arithmetic operations without overflow. * Clients should NOT check for the presence of this value explicitly. */ #define UNLIMITED_FREE_SPACE (INT_MAX/2) /** The abstract buffer storage base class. */ class WvBufStore { // discourage copying explicit WvBufStore(const WvBufStore &other) { } protected: // the suggested granularity int granularity; /** * Creates a new buffer. * "_granularity" is the suggested granularity for data allocation * and alignment purposes */ explicit WvBufStore(int _granularity); public: virtual ~WvBufStore() { } /*** Buffer Reading ***/ virtual bool isreadable() const { return true; } virtual size_t used() const = 0; virtual size_t optgettable() const { return used(); } virtual const void *get(size_t count) = 0; virtual void skip(size_t count) { get(count); } virtual void unget(size_t count) = 0; virtual size_t ungettable() const = 0; virtual size_t peekable(int offset) const; virtual size_t optpeekable(int offset) const { return peekable(offset); } virtual const void *peek(int offset, size_t count) { return mutablepeek(offset, count); } virtual void zap() = 0; // helpers void move(void *buf, size_t count); void copy(void *buf, int offset, size_t count); /*** Buffer Writing ***/ virtual bool iswritable() const { return true; } virtual size_t free() const = 0; virtual size_t optallocable() const { return free(); } virtual void *alloc(size_t count) = 0; virtual void unalloc(size_t count) = 0; virtual size_t unallocable() const = 0; virtual void *mutablepeek(int offset, size_t count) = 0; // helpers void put(const void *data, size_t count); void fastput(const void *data, size_t count); void poke(const void *data, int offset, size_t count); /*** Buffer to Buffer Transfers ***/ virtual void merge(WvBufStore &instore, size_t count); // default implementation void basicmerge(WvBufStore &instore, size_t count); protected: /*** Support for buffers with subbuffers ***/ /** Returns true if the buffer uses subbuffers for storage. */ virtual bool usessubbuffers() const { return false; } /** Returns the number of subbuffers in the buffer. */ virtual size_t numsubbuffers() const { return 0; } /** * Returns the first subbuffer. * Returns: the buffer or NULL if none or not supported */ virtual WvBufStore *firstsubbuffer() const { return NULL; } /** Appends a subbuffer to the buffer. */ virtual void appendsubbuffer(WvBufStore *buffer, bool autofree) { /*assert(! "not supported");*/ } /** Prepends a subbuffer to the buffer. */ virtual void prependsubbuffer(WvBufStore *buffer, bool autofree) { /*assert(! "not supported");*/ } /** * Unlinks the specified subbuffer. * Only autofrees the buffer if allowautofree == true. * Returns: the autofree flag for the buffer */ virtual bool unlinksubbuffer(WvBufStore *buffer, bool allowautofree) { /*assert(! "not supported");*/ return true; } }; // lists of buffer stores are sometimes useful DeclareWvList(WvBufStore); /** * A statically bound mixin template for buffer implementations that are * read-only. It is an error to attempt to write to a read-only buffer. * Note that read-only in this context does not mean the same as "const". */ template<class Super> class WvReadOnlyBufferStoreMixin : public Super { public: explicit WvReadOnlyBufferStoreMixin(int _granularity) : Super(_granularity) { } virtual bool iswritable() const { return false; } virtual size_t free() const { return 0; } virtual size_t optallocable() const { return 0; } virtual void *alloc(size_t count) { assert(count == 0 || ! "non-zero alloc() called on non-writable buffer"); return NULL; } virtual void unalloc(size_t count) { assert(count == 0 || ! "non-zero unalloc() called on non-writable buffer"); } virtual size_t unallocable() const { return 0; } virtual void *mutablepeek(int offset, size_t count) { assert(count == 0 || ! "mutablepeek() called on non-writable buffer"); return NULL; } virtual void merge(WvBufStore &instore, size_t count) { assert(count == 0 || ! "non-zero merge() called on non-writable buffer"); } }; /** * A statically bound mixin template for buffer implementations that are * write-only. It is an error to attempt to read from a write-only buffer. */ template<class Super> class WvWriteOnlyBufferStoreMixin : public Super { public: explicit WvWriteOnlyBufferStoreMixin(int _granularity) : Super(_granularity) { } virtual bool isreadable() const { return false; } virtual size_t used() const { return 0; } virtual size_t optgettable() const { return 0; } virtual size_t peekable(int offset) const { return 0; } virtual size_t optpeekable(int offset) const { return 0; } virtual const void *get(size_t count) { assert(count == 0 || ! "non-zero get() called on non-readable buffer"); return NULL; } virtual void skip(size_t count) { assert(count == 0 || ! "non-zero skip() called on non-readable buffer"); } virtual void unget(size_t count) { assert(count == 0 || ! "non-zero unget() called on non-readable buffer"); } virtual size_t ungettable() const { return 0; } virtual const void *peek(int offset, size_t count) { assert(count == 0 || ! "peek() called on non-readable buffer"); return NULL; } virtual void zap() { // nothing to zap } }; /** The WvInPlaceBuf storage class. */ class WvInPlaceBufStore : public WvBufStore { protected: void *data; size_t xsize; size_t readidx; size_t writeidx; bool xautofree; public: WvInPlaceBufStore(int _granularity, void *_data, size_t _avail, size_t _size, bool _autofree); WvInPlaceBufStore(int _granularity, size_t _size); virtual ~WvInPlaceBufStore(); void *ptr() const { return data; } size_t size() const { return xsize; } bool get_autofree() const { return xautofree; } void set_autofree(bool _autofree) { xautofree = _autofree; } void reset(void *_data, size_t _avail, size_t _size, bool _autofree); void setavail(size_t _avail); /*** Overridden Members ***/ virtual size_t used() const; virtual const void *get(size_t count); virtual void unget(size_t count); virtual size_t ungettable() const; virtual void zap(); virtual size_t free() const; virtual void *alloc(size_t count); virtual void unalloc(size_t count); virtual size_t unallocable() const; virtual void *mutablepeek(int offset, size_t count); }; /** The WvConstInPlaceBuf storage class. */ class WvConstInPlaceBufStore : public WvReadOnlyBufferStoreMixin<WvBufStore> { protected: const void *data; size_t avail; size_t readidx; public: WvConstInPlaceBufStore(int _granularity, const void *_data, size_t _avail); const void *ptr() const { return data; } void reset(const void *_data, size_t _avail); void setavail(size_t _avail); /*** Overridden Members ***/ virtual size_t used() const; virtual const void *get(size_t count); virtual void unget(size_t count); virtual size_t ungettable() const; virtual const void *peek(int offset, size_t count); virtual void zap(); }; /** The WvCircularBuf storage class. */ class WvCircularBufStore : public WvBufStore { protected: void *data; size_t xsize; size_t head; size_t totalused; size_t totalinit; bool xautofree; public: WvCircularBufStore(int _granularity, void *_data, size_t _avail, size_t _size, bool _autofree); WvCircularBufStore(int _granularity, size_t _size); virtual ~WvCircularBufStore(); void *ptr() const { return data; } size_t size() const { return xsize; } bool get_autofree() const { return xautofree; } void set_autofree(bool _autofree) { xautofree = _autofree; } void reset(void *_data, size_t _avail, size_t _size, bool _autofree); void setavail(size_t _avail); void normalize(); /*** Overridden Members ***/ virtual size_t used() const; virtual size_t optgettable() const; virtual const void *get(size_t count); virtual void unget(size_t count); virtual size_t ungettable() const; virtual void zap(); virtual size_t free() const; virtual size_t optallocable() const; virtual void *alloc(size_t count); virtual void unalloc(size_t count); virtual size_t unallocable() const; virtual void *mutablepeek(int offset, size_t count); protected: /** * Ensures that count new bytes can be read from or written * to the buffer beginning at the specified offset as one * large contiguous block. * * "offset" is the offset * "count" is the number of bytes * "keephistory" is if true, does not purge unget history * Returns: the offset of the first available byte */ size_t ensurecontiguous(int offset, size_t count, bool keephistory); /** * Compacts an array arranged as a circular buffer such that * the specified region is moved to the beginning of the array. * * "data" is the array base * "size" is the size of the array * "head" is the beginning of the region to keep * "count" is the number of bytes in the region to keep */ static void compact(void *data, size_t size, size_t head, size_t count); }; /** * The WvLinkedBuffer storage class. * * A buffer store built out of a list of other buffers linked together. * Buffers may be appended or prepended to the list at any time, at * which point they act as slaves for the master buffer. Slaves may * be expunged from the list at any time when the master buffer * determines that they are of no further use. * * This is mostly useful for building other buffer storage classes. * */ class WvLinkedBufferStore : public WvBufStore { protected: WvBufStoreList list; size_t totalused; size_t maxungettable; public: explicit WvLinkedBufferStore(int _granularity); /*** Overridden Members ***/ virtual size_t used() const; virtual size_t optgettable() const; virtual const void *get(size_t count); virtual void unget(size_t count); virtual size_t ungettable() const; virtual void zap(); virtual size_t free() const; virtual size_t optallocable() const; virtual void *alloc(size_t count); virtual void unalloc(size_t count); virtual size_t unallocable() const; virtual size_t optpeekable(int offset) const; virtual void *mutablepeek(int offset, size_t count); protected: virtual bool usessubbuffers() const; virtual size_t numsubbuffers() const; virtual WvBufStore *firstsubbuffer() const; virtual void appendsubbuffer(WvBufStore *buffer, bool autofree); virtual void prependsubbuffer(WvBufStore *buffer, bool autofree); virtual bool unlinksubbuffer(WvBufStore *buffer, bool allowautofree); protected: /** * Called when a new buffer must be allocated to coalesce chunks. * * "minsize" is the minimum size for the new buffer * Returns: the new buffer */ virtual WvBufStore *newbuffer(size_t minsize); /** * Called when a buffer with autofree is removed from the list. * This function is not called during object destruction. * * "buffer" is the buffer to be destroyed */ virtual void recyclebuffer(WvBufStore *buffer); /** * Searches for the buffer containing the offset. * * "it" is the iterator updated to point to buffer found, * or to an invalid region if the offset is invalid * "offset" is the offset for which to search * Returns: the corrected offset within the buffer at it.ptr() */ int search(WvBufStoreList::Iter &it, int offset) const; /** * Coalesces a sequence of buffers. * * "it" is the iterator pointing to the first buffer * "count" is the required number of contiguous used bytes * Returns: the composite buffer */ WvBufStore *coalesce(WvBufStoreList::Iter &it, size_t count); private: // unlinks and recycles the buffer pointed at by the iterator void do_xunlink(WvBufStoreList::Iter &it); }; /** The WvDynBuf storage class. */ class WvDynBufStore : public WvLinkedBufferStore { size_t minalloc; size_t maxalloc; public: WvDynBufStore(size_t _granularity, size_t _minalloc, size_t _maxalloc); /*** Overridden Members ***/ virtual size_t free() const; virtual size_t optallocable() const; virtual void *alloc(size_t count); protected: virtual WvBufStore *newbuffer(size_t minsize); }; /** The WvNullBuf storage class. */ class WvNullBufStore : public WvWriteOnlyBufferStoreMixin< WvReadOnlyBufferStoreMixin<WvBufStore> > { public: explicit WvNullBufStore(size_t _granularity); }; /** The WvBufCursor storage class. */ class WvBufCursorStore : public WvReadOnlyBufferStoreMixin<WvBufStore> { protected: WvBufStore *buf; int start; size_t length; size_t shift; public: WvBufCursorStore(size_t _granularity, WvBufStore *_buf, int _start, size_t _length); /*** Overridden Members ***/ virtual bool isreadable() const; virtual size_t used() const; virtual size_t optgettable() const; virtual const void *get(size_t count); virtual void skip(size_t count); virtual void unget(size_t count); virtual size_t ungettable() const; virtual size_t peekable(int offset) const; virtual size_t optpeekable(int offset) const; virtual const void *peek(int offset, size_t count); virtual void zap(); virtual bool iswritable() const; virtual void *mutablepeek(int offset, size_t count); }; #endif // __WVBUFFERSTORE_H