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