1 // Simple smart pointer class.
2 
3 #ifndef SMARTPTR_H
4 #define SMARTPTR_H
5 
6 typedef unsigned long int ulint;
7 
8 template <class T>
9 class smartPtrBase
10 {
11  public:  // ----------------------------------------------------------------
12 
13     // --- constructors ---
14 
15     smartPtrBase(T* buffer, ulint bufferLen, bool bufOwner = false) : dummy(0)
16     {
17         doFree = bufOwner;
18         if ( bufferLen >= 1 )
19         {
20             pBufCurrent = ( bufBegin = buffer );
21             bufEnd = bufBegin + bufferLen;
22             bufLen = bufferLen;
23             status = true;
24         }
25         else
26         {
27             pBufCurrent = ( bufBegin = ( bufEnd = 0 ));
28             bufLen = 0;
29             status = false;
30         }
31     }
32 
33     // --- destructor ---
34 
~smartPtrBase()35     virtual ~smartPtrBase()
36     {
37         if ( doFree && (bufBegin != 0) )
38         {
39             delete[] bufBegin;
40         }
41     }
42 
43     // --- public member functions ---
44 
tellBegin()45     virtual T* tellBegin()  { return bufBegin; }
tellLength()46     virtual ulint tellLength()  { return bufLen; }
tellPos()47     virtual ulint tellPos()  { return (ulint)(pBufCurrent-bufBegin); }
48 
checkIndex(ulint index)49     virtual bool checkIndex(ulint index)
50     {
51         return ((pBufCurrent+index)<bufEnd);
52     }
53 
reset()54     virtual bool reset()
55     {
56         if ( bufLen >= 1 )
57         {
58             pBufCurrent = bufBegin;
59             return (status = true);
60         }
61         else
62         {
63             return (status = false);
64         }
65     }
66 
good()67     virtual bool good()
68     {
69         return (pBufCurrent<bufEnd);
70     }
71 
fail()72     virtual bool fail()
73     {
74         return (pBufCurrent==bufEnd);
75     }
76 
77     virtual void operator ++()
78     {
79         if ( good() )
80         {
81             pBufCurrent++;
82         }
83         else
84         {
85             status = false;
86         }
87     }
88 
89     virtual void operator ++(int)
90     {
91         if ( good() )
92         {
93             pBufCurrent++;
94         }
95         else
96         {
97             status = false;
98         }
99     }
100 
101     virtual void operator --()
102     {
103         if ( !fail() )
104         {
105             pBufCurrent--;
106         }
107         else
108         {
109             status = false;
110         }
111     }
112 
113     virtual void operator --(int)
114     {
115         if ( !fail() )
116         {
117             pBufCurrent--;
118         }
119         else
120         {
121             status = false;
122         }
123     }
124 
125     virtual void operator +=(ulint offset)
126     {
127         if (checkIndex(offset))
128         {
129             pBufCurrent += offset;
130         }
131         else
132         {
133             status = false;
134         }
135     }
136 
137     virtual void operator -=(ulint offset)
138     {
139         if ((pBufCurrent-offset) >= bufBegin)
140         {
141             pBufCurrent -= offset;
142         }
143         else
144         {
145             status = false;
146         }
147     }
148 
149     T operator*()
150     {
151         if ( good() )
152         {
153             return *pBufCurrent;
154         }
155         else
156         {
157             status = false;
158             return dummy;
159         }
160     }
161 
162     T& operator [](ulint index)
163     {
164         if (checkIndex(index))
165         {
166             return pBufCurrent[index];
167         }
168         else
169         {
170             status = false;
171             return dummy;
172         }
173     }
174 
175     virtual operator bool()  { return status; }
176 
177  protected:  // -------------------------------------------------------------
178 
179     T* bufBegin;
180     T* bufEnd;
181     T* pBufCurrent;
182     ulint bufLen;
183     bool status;
184     bool doFree;
185     T dummy;
186 };
187 
188 
189 template <class T>
190 class smartPtr : public smartPtrBase<T>
191 {
192  public:  // ----------------------------------------------------------------
193 
194     // --- constructors ---
195 
196     smartPtr(T* buffer, ulint bufferLen, bool bufOwner = false)
197         : smartPtrBase<T>(buffer, bufferLen, bufOwner)
198     {
199     }
200 
smartPtr()201     smartPtr()
202         : smartPtrBase<T>(0,0)
203     {
204     }
205 
setBuffer(T * buffer,ulint bufferLen)206     void setBuffer(T* buffer, ulint bufferLen)
207     {
208         if ( bufferLen >= 1 )
209         {
210             this->pBufCurrent = ( this->bufBegin = buffer );
211             this->bufEnd = this->bufBegin + bufferLen;
212             this->bufLen = bufferLen;
213             this->status = true;
214         }
215         else
216         {
217             this->pBufCurrent = this->bufBegin = this->bufEnd = 0;
218             this->bufLen = 0;
219             this->status = false;
220         }
221     }
222 };
223 
224 #endif  // SMARTPTR_H
225