Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

wvbufbase.h

00001 /* -*- Mode: C++ -*-
00002  * Worldvisions Weaver Software:
00003  *   Copyright (C) 1997-2002 Net Integration Technologies, Inc.
00004  *
00005  * A generic buffering API.
00006  * Please declare specializations in a separate header file,
00007  * See "wvbuf.h".
00008  */
00009 #ifndef __WVBUFFERBASE_H
00010 #define __WVBUFFERBASE_H
00011 
00012 #include "wvbufstore.h"
00013 
00014 template<class T>
00015 class WvBufBase;
00016 
00035 template<class T>
00036 class WvBufBaseCommonImpl
00037 {
00038 protected:
00039     typedef T Elem;
00040     typedef WvBufBase<T> Buffer;
00041 
00042     WvBufStore *store;
00043     
00044     // discourage copying
00045     explicit WvBufBaseCommonImpl(
00046         const WvBufBaseCommonImpl &other) { }
00047 
00048 protected:
00057     explicit WvBufBaseCommonImpl(WvBufStore *store) :
00058         store(store) { }
00059 
00060 public:
00062     virtual ~WvBufBaseCommonImpl() { }
00063 
00069     WvBufStore *getstore()
00070     {
00071         return store;
00072     }
00073 
00074     /*** Buffer Reading ***/
00075 
00081     bool isreadable() const
00082     {
00083         return store->isreadable();
00084     }
00085     
00092     size_t used() const
00093     {
00094         return store->used() / sizeof(Elem);
00095     }
00096 
00113     const T *get(size_t count)
00114     {
00115         if (count > used())
00116             return NULL;
00117 
00118         return static_cast<const T*>(
00119             store->get(count * sizeof(Elem)));
00120     }
00121 
00133     void skip(size_t count)
00134     {
00135         store->skip(count * sizeof(Elem));
00136     }
00137 
00151     size_t optgettable() const
00152     {
00153         size_t avail = store->optgettable();
00154         size_t elems = avail / sizeof(Elem);
00155         if (elems != 0) return elems;
00156         return avail != 0 && store->used() >= sizeof(Elem) ? 1 : 0;
00157     }
00158 
00174     void unget(size_t count)
00175     {
00176         store->unget(count * sizeof(Elem));
00177     }
00178 
00185     size_t ungettable() const
00186     {
00187         return store->ungettable() / sizeof(Elem);
00188     }
00189 
00222     const T *peek(int offset, size_t count)
00223     {
00224         return static_cast<const T*>(store->peek(
00225             offset * sizeof(Elem), count * sizeof(Elem)));
00226     }
00227 
00228     size_t peekable(int offset)
00229     {
00230         return store->peekable(offset * sizeof(Elem)) / sizeof(Elem);
00231     }
00232 
00233     size_t optpeekable(int offset)
00234     {
00235         offset *= sizeof(Elem);
00236         size_t avail = store->optpeekable(offset);
00237         size_t elems = avail / sizeof(Elem);
00238         if (elems != 0) return elems;
00239         return avail != 0 &&
00240             store->peekable(offset) >= sizeof(Elem) ? 1 : 0;
00241     }
00242 
00254     void zap()
00255     {
00256         store->zap();
00257     }
00258 
00269     T get()
00270     {
00271         return *get(1);
00272     }
00273 
00283     T peek(int offset = 0)
00284     {
00285         return *peek(offset * sizeof(Elem), sizeof(Elem));
00286     }
00287 
00306     void move(T *buf, size_t count)
00307     {
00308         store->move(buf, count * sizeof(Elem));
00309     }
00310     
00327     void copy(T *buf, int offset, size_t count)
00328     {
00329         store->copy(buf, offset * sizeof(Elem), count * sizeof(Elem));
00330     }
00331     
00332     /*** Buffer Writing ***/
00333     
00339     bool iswritable() const
00340     {
00341         return true;
00342     }
00343     
00350     size_t free() const
00351     {
00352         return store->free() / sizeof(Elem);
00353     }
00354     
00376     T *alloc(size_t count)
00377     {
00378         return static_cast<T*>(store->alloc(count * sizeof(Elem)));
00379     }
00380     
00394     size_t optallocable() const
00395     {
00396         size_t avail = store->optallocable();
00397         size_t elems = avail / sizeof(Elem);
00398         if (elems != 0) return elems;
00399         return avail != 0 && store->free() >= sizeof(Elem) ? 1 : 0;
00400     }
00401 
00418     void unalloc(size_t count)
00419     {
00420         return store->unalloc(count * sizeof(Elem));
00421     }
00422 
00440     size_t unallocable() const
00441     {
00442         return store->unallocable() / sizeof(Elem);
00443     }
00444     
00458     T *mutablepeek(int offset, size_t count)
00459     {
00460         return static_cast<T*>(store->mutablepeek(
00461             offset * sizeof(Elem), count * sizeof(Elem)));
00462     }
00463 
00480     void put(const T *data, size_t count)
00481     {
00482         store->put(data, count * sizeof(Elem));
00483     }
00484 
00501     void poke(const T *data, int offset, size_t count)
00502     {
00503         store->poke(data, offset * sizeof(Elem), count * sizeof(Elem));
00504     }
00505 
00516     void put(T &value)
00517     {
00518         store->fastput(& value, sizeof(Elem));
00519     }
00520 
00532     void poke(T &value, int offset)
00533     {
00534         poke(& value, offset, 1);
00535     }
00536 
00537 
00538     /*** Buffer to Buffer Transfers ***/
00539 
00555     void merge(Buffer &inbuf, size_t count)
00556     {
00557         store->merge(*inbuf.store, count * sizeof(Elem));
00558     }
00559 
00565     void merge(Buffer &inbuf)
00566     {
00567         merge(inbuf, inbuf.used());
00568     }
00569 };
00570 
00571 
00572 
00582 template<class T>
00583 class WvBufBase : public WvBufBaseCommonImpl<T>
00584 {
00585 public:
00586     explicit WvBufBase(WvBufStore *store) :
00587         WvBufBaseCommonImpl<T>(store) { }
00588 };
00589 
00590 
00591 
00599 template<class T>
00600 class WvInPlaceBufBase : public WvBufBase<T>
00601 {
00602 protected:
00603     typedef T Elem;
00604 
00605     WvInPlaceBufStore mystore;
00606 
00607 public:
00616     WvInPlaceBufBase(T *_data, size_t _avail, size_t _size,
00617         bool _autofree = false) :
00618         WvBufBase<T>(& mystore),
00619         mystore(sizeof(Elem), _data, _avail * sizeof(Elem),
00620             _size * sizeof(Elem), _autofree) { }
00621 
00627     explicit WvInPlaceBufBase(size_t _size) :
00628         WvBufBase<T>(& mystore),
00629         mystore(sizeof(Elem), _size * sizeof(Elem)) { }
00630 
00632     WvInPlaceBufBase() :
00633         WvBufBase<T>(& mystore),
00634         mystore(sizeof(Elem), NULL, 0, 0, false) { }
00635 
00642     virtual ~WvInPlaceBufBase() { }
00643 
00649     T *ptr() const
00650     {
00651         return static_cast<T*>(mystore.ptr());
00652     }
00653 
00659     size_t size() const
00660     {
00661         return mystore.size() / sizeof(Elem);
00662     }
00663 
00669     bool get_autofree() const
00670     {
00671         return mystore.get_autofree();
00672     }
00673 
00679     void set_autofree(bool _autofree)
00680     {
00681         mystore.set_autofree(_autofree);
00682     }
00683 
00695     void reset(T *_data, size_t _avail, size_t _size,
00696         bool _autofree = false)
00697     {
00698         mystore.reset(_data, _avail * sizeof(Elem),
00699             _size * sizeof(Elem), _autofree);
00700     }
00701 
00708     void setavail(size_t _avail)
00709     {
00710         mystore.setavail(_avail * sizeof(Elem));
00711     }
00712 };
00713 
00714 
00715 
00723 template<class T>
00724 class WvConstInPlaceBufBase : public WvBufBase<T>
00725 {
00726 protected:
00727     typedef T Elem;
00728 
00729     WvConstInPlaceBufStore mystore;
00730 
00731 public:
00738     WvConstInPlaceBufBase(const T *_data, size_t _avail) :
00739         WvBufBase<T>(& mystore),
00740         mystore(sizeof(Elem), _data, _avail * sizeof(Elem)) { }
00741 
00743     WvConstInPlaceBufBase() :
00744         WvBufBase<T>(& mystore),
00745         mystore(sizeof(Elem), NULL, 0) { }
00746 
00753     virtual ~WvConstInPlaceBufBase() { }
00754 
00760     const T *ptr() const
00761     {
00762         return static_cast<const T*>(mystore.ptr());
00763     }
00764 
00774     void reset(const T *_data, size_t _avail)
00775     {
00776         mystore.reset(_data, _avail * sizeof(Elem));
00777     }
00778 
00785     void setavail(size_t _avail)
00786     {
00787         mystore.setavail(_avail * sizeof(Elem));
00788     }
00789 };
00790 
00791 
00792 
00809 template<class T>
00810 class WvCircularBufBase : public WvBufBase<T>
00811 {
00812 protected:
00813     typedef T Elem;
00814 
00815     WvCircularBufStore mystore;
00816 
00817 public:
00827     WvCircularBufBase(T *_data, size_t _avail, size_t _size,
00828         bool _autofree = false) :
00829         WvBufBase<T>(& mystore),
00830         mystore(sizeof(Elem), _data, _avail * sizeof(Elem),
00831             _size * sizeof(Elem), _autofree) { }
00832 
00838     explicit WvCircularBufBase(size_t _size) :
00839         WvBufBase<T>(& mystore),
00840         mystore(sizeof(Elem), _size * sizeof(Elem)) { }
00841 
00843     WvCircularBufBase() :
00844         WvBufBase<T>(& mystore),
00845         mystore(sizeof(Elem), NULL, 0, 0, false) { }
00846 
00853     virtual ~WvCircularBufBase() { }
00854 
00860     T *ptr() const
00861     {
00862         return static_cast<T*>(mystore.ptr());
00863     }
00864 
00870     size_t size() const
00871     {
00872         return mystore.size() / sizeof(Elem);
00873     }
00874 
00880     bool get_autofree() const
00881     {
00882         return mystore.get_autofree();
00883     }
00884 
00890     void set_autofree(bool _autofree)
00891     {
00892         mystore.set_autofree(_autofree);
00893     }
00894 
00907     void reset(T *_data, size_t _avail, size_t _size,
00908         bool _autofree = false)
00909     {
00910         mystore.reset(_data, _avail * sizeof(Elem),
00911             _size * sizeof(Elem), _autofree);
00912     }
00913 
00921     void setavail(size_t _avail)
00922     {
00923         mystore.setavail(_avail * sizeof(Elem));
00924     }
00925 
00935     void normalize()
00936     {
00937         mystore.normalize();
00938     }
00939 };
00940 
00941 
00942 
00949 template<class T>
00950 class WvDynBufBase : public WvBufBase<T>
00951 {
00952 protected:
00953     typedef T Elem;
00954 
00955     WvDynBufStore mystore;
00956     
00957 public:
00970     explicit WvDynBufBase(size_t _minalloc = 1024,
00971         size_t _maxalloc = 1048576) :
00972         WvBufBase<T>(& mystore),
00973         mystore(sizeof(Elem), _minalloc * sizeof(Elem),
00974             _maxalloc * sizeof(Elem)) { }
00975 };
00976 
00977 
00978 
00985 template<class T>
00986 class WvNullBufBase : public WvBufBase<T>
00987 {
00988 protected:
00989     typedef T Elem;
00990 
00991     WvNullBufStore mystore;
00992 
00993 public:
00995     WvNullBufBase() :
00996         WvBufBase<T>(& mystore),
00997         mystore(sizeof(Elem)) { }
00998 };
00999 
01000 
01001 
01010 template<class T>
01011 class WvBufCursorBase : public WvBufBase<T>
01012 {
01013 protected:
01014     typedef T Elem;
01015 
01016     WvBufCursorStore mystore;
01017 
01018 public:
01029     WvBufCursorBase(WvBufBase<T> &_buf, int _start,
01030         size_t _length) :
01031         WvBufBase<T>(& mystore),
01032         mystore(sizeof(Elem), _buf.getstore(),
01033             _start * sizeof(Elem), _length * sizeof(Elem)) { }
01034 };
01035 
01036 
01048 template<class T>
01049 class WvBufViewBase : public WvBufBase<T>
01050 {
01051 public:
01060     template<typename S>
01061     WvBufViewBase(WvBufBase<S> &_buf) :
01062         WvBufBase<T>(_buf.getstore()) { }
01063 };
01064 
01065 #endif // __WVBUFFERBASE_H

Generated on Tue Jul 12 02:59:27 2005 for WvStreams by  doxygen 1.4.0