00001
00002
00003
00004
00005
00006
00007
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
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
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
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
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