libsidplayfp  1.0.3
SmartPtr.h
00001 /* Simple smart pointer class. */
00002 
00003 #ifndef SMARTPTR_H
00004 #define SMARTPTR_H
00005 
00006 typedef unsigned long int ulint_smartpt;
00007 
00008 template <class T>
00009 class SmartPtrBase_sidtt
00010 {
00011  public:
00012         /* --- constructors --- */
00013         
00014         SmartPtrBase_sidtt(T* buffer, ulint_smartpt bufferLen, bool bufOwner = false) : dummy(0)
00015         {
00016                 doFree = bufOwner;
00017                 if ( bufferLen )
00018                 {
00019                         bufBegin = buffer;
00020                         pBufCurrent = buffer;
00021                         bufEnd = bufBegin + bufferLen;
00022                         bufLen = bufferLen;
00023                         status = true;
00024                 }
00025                 else
00026                 {
00027                         bufBegin = 0;
00028                         pBufCurrent = 0;
00029                         bufEnd = 0;
00030                         bufLen = 0;
00031                         status = false;
00032                 }
00033         }
00034 
00035         /* --- destructor --- */
00036 
00037         virtual ~SmartPtrBase_sidtt()
00038         {
00039                 if ( doFree && bufBegin )
00040                 {
00041 #ifndef SID_HAVE_BAD_COMPILER
00042                         delete[] bufBegin;
00043 #else
00044                         delete[] (void*)bufBegin;
00045 #endif
00046                 }
00047         }
00048 
00049         /* --- public member functions --- */
00050 
00051         virtual T* tellBegin() const { return bufBegin; }
00052         virtual ulint_smartpt tellLength() const { return bufLen; }
00053         virtual ulint_smartpt tellPos() const { return (ulint_smartpt)(pBufCurrent-bufBegin); }
00054 
00055         virtual bool checkIndex(ulint_smartpt index)
00056         {
00057                 return ((pBufCurrent+index)<bufEnd);
00058         }
00059 
00060         virtual bool reset()
00061         {
00062                 if ( bufLen )
00063                 {
00064                         pBufCurrent = bufBegin;
00065                         return (status = true);
00066                 }
00067                 else
00068                 {
00069                         return (status = false);
00070                 }
00071         }
00072 
00073         virtual bool good()
00074         {
00075                 return (pBufCurrent<bufEnd);
00076         }
00077 
00078         virtual bool fail()
00079         {
00080                 return (pBufCurrent==bufEnd);
00081         }
00082 
00083         virtual void operator ++()
00084         {
00085                 if ( good() )
00086                 {
00087                         pBufCurrent++;
00088                 }
00089                 else
00090                 {
00091                         status = false;
00092                 }
00093         }
00094 
00095         virtual void operator ++(int)
00096         {
00097                 if ( good() )
00098                 {
00099                         pBufCurrent++;
00100                 }
00101                 else
00102                 {
00103                         status = false;
00104                 }
00105         }
00106 
00107         virtual void operator --()
00108         {
00109                 if ( !fail() )
00110                 {
00111                         pBufCurrent--;
00112                 }
00113                 else
00114                 {
00115                         status = false;
00116                 }
00117         }
00118 
00119         virtual void operator --(int)
00120         {
00121                 if ( !fail() )
00122                 {
00123                         pBufCurrent--;
00124                 }
00125                 else
00126                 {
00127                         status = false;
00128                 }
00129         }
00130 
00131         virtual void operator +=(ulint_smartpt offset)
00132         {
00133                 if (checkIndex(offset))
00134                 {
00135                         pBufCurrent += offset;
00136                 }
00137                 else
00138                 {
00139                         status = false;
00140                 }
00141         }
00142 
00143         virtual void operator -=(ulint_smartpt offset)
00144         {
00145                 if ((pBufCurrent-offset) >= bufBegin)
00146                 {
00147                         pBufCurrent -= offset;
00148                 }
00149                 else
00150                 {
00151                         status = false;
00152                 }
00153         }
00154 
00155         virtual T operator*()
00156         {
00157                 if ( good() )
00158                 {
00159                         return *pBufCurrent;
00160                 }
00161                 else
00162                 {
00163                         status = false;
00164                         return dummy;
00165                 }
00166         }
00167 
00168         virtual T& operator [](ulint_smartpt index)
00169         {
00170                 if (checkIndex(index))
00171                 {
00172                         return pBufCurrent[index];
00173                 }
00174                 else
00175                 {
00176                         status = false;
00177                         return dummy;
00178                 }
00179         }
00180 
00181         virtual operator bool()  { return status; }
00182 
00183  protected:
00184         T* bufBegin;
00185         T* bufEnd;
00186         T* pBufCurrent;
00187         ulint_smartpt bufLen;
00188         bool status;
00189         bool doFree;
00190         T dummy;
00191 };
00192 
00193 
00194 template <class T>
00195 class SmartPtr_sidtt : public SmartPtrBase_sidtt<T>
00196 {
00197  public:
00198         /* --- constructors --- */
00199 
00200         SmartPtr_sidtt(T* buffer, ulint_smartpt bufferLen, bool bufOwner = false)
00201                 : SmartPtrBase_sidtt<T>(buffer, bufferLen, bufOwner)
00202         {
00203         }
00204 
00205         SmartPtr_sidtt()
00206                 : SmartPtrBase_sidtt<T>(0,0)
00207         {
00208         }
00209 
00210         void setBuffer(T* buffer, ulint_smartpt bufferLen)
00211         {
00212                 if ( bufferLen )
00213                 {
00214                         this->bufBegin = buffer;
00215                         this->pBufCurrent = buffer;
00216                         this->bufEnd = buffer + bufferLen;
00217                         this->bufLen = bufferLen;
00218                         this->status = true;
00219                 }
00220                 else
00221                 {
00222                         this->bufBegin = 0;
00223                         this->pBufCurrent = 0;
00224                         this->bufEnd = 0;
00225                         this->bufLen = 0;
00226                         this->status = false;
00227                 }
00228         }
00229 };
00230 
00231 #endif  /* SMARTPTR_H */