Correct code and enable tests for ETL "spline" and "value"
[synfig.git] / ETL / ETL / _smart_ptr.h
1 /* ========================================================================
2 ** Extended Template and Library
3 ** Template Smart Pointer Implementation
4 ** $Id$
5 **
6 ** Copyright (c) 2002 Robert B. Quattlebaum Jr.
7 **
8 ** This package is free software; you can redistribute it and/or
9 ** modify it under the terms of the GNU General Public License as
10 ** published by the Free Software Foundation; either version 2 of
11 ** the License, or (at your option) any later version.
12 **
13 ** This package is distributed in the hope that it will be useful,
14 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 ** General Public License for more details.
17 **
18 ** === N O T E S ===========================================================
19 **
20 ** This is an internal header file, included by other ETL headers.
21 ** You should not attempt to use it directly.
22 **
23 ** ========================================================================= */
24
25 /* === S T A R T =========================================================== */
26
27 #ifndef __ETL__SMART_PTR_H
28 #define __ETL__SMART_PTR_H
29
30 /* === H E A D E R S ======================================================= */
31
32 #include <cassert>
33 #include "_ref_count.h"
34
35 /* === M A C R O S ========================================================= */
36
37 /* === T Y P E D E F S ===================================================== */
38
39 /* === C L A S S E S & S T R U C T S ======================================= */
40
41 _ETL_BEGIN_NAMESPACE
42
43 template <class T>
44 struct generic_deleter
45 {
46         void operator()(T* x)const { delete x; }
47 };
48
49 template <class T>
50 struct array_deleter
51 {
52         void operator()(T* x)const { delete [] x; }
53 };
54
55 // ========================================================================
56 /*!     \class  smart_ptr       _smart_ptr.h    ETL/smart_ptr
57 **      \brief  Object Smart Pointer
58 **      \see loose_smart_ptr
59 **      \writeme
60 */
61 template <class T, class D=generic_deleter<T> >
62 class smart_ptr
63 {
64 public:
65
66         typedef T value_type;
67         typedef T& reference;
68         typedef const T& const_reference;
69         typedef T* pointer;
70         typedef const T* const_pointer;
71         typedef int count_type;
72         typedef int size_type;
73         typedef D destructor_type;
74
75 #ifdef DOXYGEN_SHOULD_SKIP_THIS         // #ifdef is not a typo
76 private:
77 #endif
78         value_type *obj;                //!< \internal Pointer to object
79         reference_counter refcount;
80
81 public:
82         // Private constructor for convenience
83         smart_ptr(value_type* obj,reference_counter refcount):obj(obj),refcount(refcount) {  }
84
85         //! Default constructor - empty smart_ptr
86         smart_ptr():obj(0),refcount(false) {}
87
88         //! Constructor that constructs from a pointer to new object
89         /*! A new smart_ptr is created with a pointer
90                 to a newly allocated object. We need
91                 to be explicit with this so we don't
92                 accidently have two smart_ptrs for one
93                 object -- that would be bad.    */
94         explicit smart_ptr(value_type* x):obj(x),refcount(x?true:false) {  }
95
96         //! Template copy constructor
97         /*! This template constructor allows us to cast
98                 smart_ptrs much like we would pointers. */
99 #ifdef _WIN32
100         template <class U>
101         smart_ptr(const smart_ptr<U> &x):obj((pointer)&*x.obj),refcount(x.refcount())
102                 { }
103 #endif
104
105         //! Default copy constructor
106         /*! The template above is not good enough
107                 for all compilers. We need to explicitly
108                 define the copy constructor for this
109                 class to work on those compilers. */
110         smart_ptr(const smart_ptr<value_type> &x):obj(x.obj),refcount(x.refcount) {  }
111
112         explicit smart_ptr(const value_type &x):obj(new value_type(x)) { }
113
114         //! smart_ptr is released on deletion
115         ~smart_ptr() { if(refcount.unique()) destructor_type()(obj); }
116
117         //! Template Assignment operator
118         template <class U> const smart_ptr<value_type> &
119         operator=(const smart_ptr<U> &x)
120         {
121                 if(x.get()==obj)
122                         return *this;
123
124                 reset();
125
126                 if(x.obj)
127                 {
128                         obj=(pointer)x.get();
129                         refcount=x.refcount;
130                 }
131
132                 return *this;
133         }
134
135         //! Assignment operator
136         const smart_ptr<value_type> &
137         operator=(const smart_ptr<value_type> &x)
138         {
139                 if(x.get()==obj)
140                         return *this;
141
142                 reset();
143
144                 if(x.obj)
145                 {
146
147                         obj=(pointer)x.get();
148                         refcount=x.refcount;
149                 }
150
151                 return *this;
152         }
153
154         //! smart_ptr reset procedure
155         void
156         reset()
157         {
158                 if(obj)
159                 {
160                         if(refcount.unique()) destructor_type()(obj);
161                         refcount.detach();
162                         obj=0;
163                 }
164         }
165
166         void spawn() { operator=(smart_ptr(new T)); }
167
168         //! Returns number of instances
169         const count_type& count()const { return refcount; }
170
171         //! Returns true if there is only one instance of the object
172         bool unique()const { return refcount.unique(); }
173
174         //! Returns a constant handle to our object
175         smart_ptr<const value_type> constant() { return *this; }
176
177         reference operator*()const { assert(obj); return *obj; }
178
179         pointer operator->()const { assert(obj); return obj; }
180
181
182         operator smart_ptr<const value_type>()const
183         { return smart_ptr<const value_type>(static_cast<const_pointer>(obj)); }
184
185         //! static_cast<> wrapper
186         template <class U> static
187         smart_ptr<T> cast_static(const smart_ptr<U> &x)
188         { if(!x)return NULL; return smart_ptr<T>(static_cast<T*>(x.get()),x.refcount); }
189
190         //! dynamic_cast<> wrapper
191         template <class U> static
192         smart_ptr<T> cast_dynamic(const smart_ptr<U> &x)
193         { if(!x)return 0; return smart_ptr<T>(dynamic_cast<T*>(x.get()),x.refcount); }
194
195         //! const_cast<> wrapper
196         template <class U> static
197         smart_ptr<T> cast_const(const smart_ptr<U> &x)
198         { if(!x)return 0; return smart_ptr<T>(const_cast<T*>(x.get()),x.refcount); }
199
200         pointer get()const { return obj; }
201
202         //! More explicit bool cast
203         operator bool()const { return obj!=0; }
204
205         bool operator!()const { return !obj; }
206
207         //! Overloaded cast operator -- useful for implicit casts
208         template <class U>
209         operator smart_ptr<U>()
210         {
211                 // This next line should provide a syntax check
212                 // to make sure that this cast makes sense.
213                 // If it doesn't, this should have a compiler error.
214                 // Otherwise, it should get optimized right out
215                 // of the code.
216                 //(U*)obj;
217
218                 return *reinterpret_cast<smart_ptr<U>*>(this);
219         }
220
221 }; // END of template class smart_ptr
222
223 // ========================================================================
224 /*!     \class  loose_smart_ptr _smart_ptr.h    ETL/smart_ptr
225 **      \brief  Loose Object Smart Pointer
226 **      \see smart_ptr
227 **      \writeme
228 */
229 template <class T>
230 class loose_smart_ptr
231 {
232 public:
233
234         typedef T value_type;
235         typedef T& reference;
236         typedef const T& const_reference;
237         typedef T* pointer;
238         typedef const T* const_pointer;
239         typedef int count_type;
240         typedef int size_type;
241
242 private:
243         value_type *obj;                //!< \internal Pointer to object
244         weak_reference_counter refcount;        //!< \internal Pointer to object's reference counter
245
246 public:
247
248         //! Default constructor - empty smart_ptr
249         loose_smart_ptr():obj(0),refcount(0) {}
250
251         //! Default copy constructor
252         loose_smart_ptr(const loose_smart_ptr<value_type> &x):obj(x.get()),refcount(x.refcount) { }
253
254         loose_smart_ptr(const smart_ptr<value_type> &x):obj(x.get()),refcount(x.refcount) { }
255
256         void reset() { obj=0,refcount=0; }
257
258         operator smart_ptr<value_type>()
259         {
260                 return smart_ptr<value_type>(static_cast<pointer>(obj),refcount);
261         }
262
263         operator smart_ptr<const value_type>()
264         {
265                 return smart_ptr<const value_type>(static_cast<const_pointer>(obj),refcount);
266         }
267
268         //! Returns number of instances
269         const count_type& count()const { return refcount; }
270
271         bool unique()const { return refcount.unique(); }
272
273         reference operator*()const { assert(obj); return *obj; }
274
275         pointer operator->()const { assert(obj); return obj; }
276
277         pointer get()const { return obj; }
278
279         bool operator!()const { return !obj; }
280 };
281
282 template <class T,class U> bool
283 operator==(const smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
284         { return (lhs.get()==rhs.get()); }
285 template <class T,class U> bool
286 operator==(const loose_smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
287         { return (lhs.get()==rhs.get()); }
288 template <class T,class U> bool
289 operator==(const smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
290         { return (lhs.get()==rhs.get()); }
291 template <class T,class U> bool
292 operator==(const loose_smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
293         { return (lhs.get()==rhs.get()); }
294 template <class T> bool
295 operator==(const smart_ptr<T> &lhs,const T *rhs)
296         { return (lhs.get()==rhs); }
297 template <class T> bool
298 operator==(const loose_smart_ptr<T> &lhs,const T *rhs)
299         { return (lhs.get()==rhs); }
300 template <class T> bool
301 operator==(const T *lhs,const smart_ptr<T> &rhs)
302         { return (lhs==rhs.get()); }
303 template <class T> bool
304 operator==(const T *lhs,const loose_smart_ptr<T> &rhs)
305         { return (lhs==rhs.get()); }
306
307
308 template <class T,class U> bool
309 operator!=(const smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
310         { return (lhs.get()!=rhs.get()); }
311 template <class T,class U> bool
312 operator!=(const loose_smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
313         { return (lhs.get()!=rhs.get()); }
314 template <class T,class U> bool
315 operator!=(const smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
316         { return (lhs.get()!=rhs.get()); }
317 template <class T,class U> bool
318 operator!=(const loose_smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
319         { return (lhs.get()!=rhs.get()); }
320 template <class T> bool
321 operator!=(const smart_ptr<T> &lhs,const T *rhs)
322         { return (lhs.get()!=rhs); }
323 template <class T> bool
324 operator!=(const loose_smart_ptr<T> &lhs,const T *rhs)
325         { return (lhs.get()!=rhs); }
326 template <class T> bool
327 operator!=(const T *lhs,const smart_ptr<T> &rhs)
328         { return (lhs!=rhs.get()); }
329 template <class T> bool
330 operator!=(const T *lhs,const loose_smart_ptr<T> &rhs)
331         { return (lhs!=rhs.get()); }
332
333
334 template <class T,class U> bool
335 operator<(const smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
336         { return (lhs.get()<rhs.get()); }
337 template <class T,class U> bool
338 operator<(const loose_smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
339         { return (lhs.get()<rhs.get()); }
340 template <class T,class U> bool
341 operator<(const smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
342         { return (lhs.get()<rhs.get()); }
343 template <class T,class U> bool
344 operator<(const loose_smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
345         { return (lhs.get()<rhs.get()); }
346 template <class T> bool
347 operator<(const smart_ptr<T> &lhs,const T *rhs)
348         { return (lhs.get()<rhs); }
349 template <class T> bool
350 operator<(const loose_smart_ptr<T> &lhs,const T *rhs)
351         { return (lhs.get()<rhs); }
352 template <class T> bool
353 operator<(const T *lhs,const smart_ptr<T> &rhs)
354         { return (lhs<rhs.get()); }
355 template <class T> bool
356 operator<(const T *lhs,const loose_smart_ptr<T> &rhs)
357         { return (lhs<rhs.get()); }
358
359 _ETL_END_NAMESPACE
360
361 /* === E N D =============================================================== */
362
363 #endif