Using mutexes around accesses to refcounts seems to make the Windows build much less...
[synfig.git] / synfig-core / trunk / src / synfig / value.h
1 /* === S Y N F I G ========================================================= */
2 /*!     \file value.h
3 **      \brief Template Header
4 **
5 **      $Id$
6 **
7 **      \legal
8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 **      Copyright (c) 2007, 2008 Chris Moore
10 **
11 **      This package is free software; you can redistribute it and/or
12 **      modify it under the terms of the GNU General Public License as
13 **      published by the Free Software Foundation; either version 2 of
14 **      the License, or (at your option) any later version.
15 **
16 **      This package is distributed in the hope that it will be useful,
17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 **      General Public License for more details.
20 **      \endlegal
21 */
22 /* ========================================================================= */
23
24 /* === S T A R T =========================================================== */
25
26 #ifndef __SYNFIG_VALUE_H
27 #define __SYNFIG_VALUE_H
28
29 /* === H E A D E R S ======================================================= */
30
31 //#include "vector.h"
32 //#include "time.h"
33 #include "segment.h"
34 //#include "color.h"
35 #include "string.h"
36 #include <list>
37 #include <vector>
38 #include <ETL/trivial>
39 #include <ETL/handle>
40 #include "general.h"
41 //#include "gradient.h"
42 #include "blinepoint.h"
43 #include "exception.h"
44
45 #ifdef USE_HALF_TYPE
46 #include <OpenEXR/half.h>
47 #endif
48
49 #ifndef SYNFIG_NO_ANGLE
50 #include "angle.h"
51 #endif
52
53 #include <ETL/ref_count>
54
55 /* === M A C R O S ========================================================= */
56
57 /* === T Y P E D E F S ===================================================== */
58
59 /* === C L A S S E S & S T R U C T S ======================================= */
60
61 namespace synfig {
62
63 class Canvas;
64 class Vector;
65 class Time;
66 class Segment;
67 class Gradient;
68 class BLinePoint;
69 class Color;
70
71 /*!     \class ValueBase
72 **      \todo writeme
73 */
74 class ValueBase
75 {
76         /*
77  --     ** -- T Y P E S -----------------------------------------------------------
78         */
79
80 public:
81
82         //! \writeme
83         enum Type
84         {
85                 TYPE_NIL=0,                     //!< Represents an empty value
86
87                 TYPE_BOOL,
88                 TYPE_INTEGER,
89                 TYPE_ANGLE,                     //!< Angle
90
91                 // All types after this point are larger than 32 bits
92
93                 TYPE_TIME,                      //!< Time
94                 TYPE_REAL,                      //!< Real
95
96                 // All types after this point are larger than 64 bits
97
98                 TYPE_VECTOR,            //!< Vector
99                 TYPE_COLOR,                     //!< Color
100                 TYPE_SEGMENT,           //!< Segment
101                 TYPE_BLINEPOINT,        //!< BLinePoint
102
103                 // All types after this point require construction/destruction
104
105                 TYPE_LIST,                      //!< List
106                 TYPE_CANVAS,            //!< Canvas
107                 TYPE_STRING,            //!< String
108                 TYPE_GRADIENT,          //!< Color Gradient
109
110                 TYPE_END                        //!< Not a valid type, used for sanity checks
111         };
112
113 private:
114
115         typedef std::vector<ValueBase> list_type;
116
117         /*
118  --     ** -- D A T A -------------------------------------------------------------
119         */
120
121 protected:
122
123         Type type;
124         void *data;
125         etl::reference_counter ref_count;
126         bool loop_;
127
128         /*
129  --     ** -- C O N S T R U C T O R S -----------------------------------
130         */
131
132 public:
133
134         //! \writeme
135         ValueBase();
136
137         //! \writeme
138         template <typename T>
139         ValueBase(const T &x, bool loop_=false):
140                 type(TYPE_NIL),data(0),ref_count(0),loop_(loop_)
141                 { set(x); }
142
143         //! \writeme
144         ValueBase(Type x);
145
146         //! \writeme
147         ~ValueBase();
148
149         /*
150  --     ** -- O P E R A T O R S ---------------------------------------------------
151         */
152
153 public:
154
155         //! \writeme
156         template <class T> ValueBase& operator=(const T& x)
157                 { set(x); return *this; }
158
159         //! \writeme
160         ValueBase& operator=(const ValueBase& x);
161
162         //! \writeme
163         bool operator==(const ValueBase& rhs)const;
164
165         //! \writeme
166         bool operator!=(const ValueBase& rhs)const { return !operator==(rhs); }
167
168         //!     Constant index operator for when value is of type TYPE_LIST
169         const ValueBase &operator[](int index)const
170                 { assert(type==TYPE_LIST); assert(index>0); return get_list()[index]; }
171
172         /*
173  --     ** -- M E M B E R   F U N C T I O N S -------------------------------------
174         */
175
176 public:
177
178         //! \writeme
179         void clear();
180
181         //! \writeme
182         bool get_loop()const { return loop_; }
183
184         //! \writeme
185         void set_loop(bool x) { loop_=x; }
186
187         //! \writeme
188         bool empty()const;
189
190         //! \writeme
191         Type get_contained_type()const;
192
193         //! Returns true if the contained value is defined and valid.
194         bool is_valid()const;
195
196         //!     Returns a string containing the name of the type
197         String type_name()const { return type_name(type); }
198
199         //! Returns the type of the contained value
200         const Type & get_type()const { return type; }
201
202         //! Checks the type of the parameter against itself. Returns true if they are of the same type.
203         template <class T> bool
204         same_type_as(const T &x)const
205         {
206                 const Type testtype(get_type(x));
207
208                 return same_type_as(type, testtype);
209         }
210
211         bool same_type_as(const Type testtype)const
212         {
213                 return same_type_as(type, testtype);
214         }
215
216         //! Compares two types.  Returns true if they are the same type.
217         static bool same_type_as(const Type type1, const Type type2)
218         {
219                 if (type1 == type2) return true;
220                 if ((type1 == TYPE_REAL || type1 == TYPE_TIME) &&
221                         (type2 == TYPE_REAL || type2 == TYPE_TIME))
222                         return true;
223                 return false;
224         }
225
226
227         // === GET MEMBERS ========================================================
228         template <typename T>
229         const T &get(const T& x __attribute__ ((unused)))const
230         {
231                 assert(is_valid() && same_type_as(x));
232                 return *static_cast<const T*>(data);
233         }
234         float get(const float &)const { return get(Real()); }
235         etl::loose_handle<Canvas> get(const etl::handle<Canvas>&)const
236                 { return get(etl::loose_handle<Canvas>()); }
237         etl::loose_handle<Canvas> get(Canvas*)const
238                 { return get(etl::loose_handle<Canvas>()); }
239         const char* get(const char*)const;
240         const list_type& get_list()const { return get(list_type()); }
241         // ========================================================================
242
243
244
245         // === PUT MEMBERS ========================================================
246         template <typename T>
247         void put(T* x)const
248         {
249                 assert(same_type_as(*x));
250                 *x=*static_cast<const T*>(data);
251         }
252         void put(float* x)const { *x=get(Real()); }
253         void put(char** x)const;
254         // ========================================================================
255
256
257
258         // === SET MEMBERS ========================================================
259         template <typename T> void set(const T& x) { _set(x); }
260         void set(const float &x) { _set(Real(x)); }
261         void set(const list_type &x);
262         void set(const char* x);
263         void set(char* x);
264         void set(Canvas*x);
265         void set(etl::loose_handle<Canvas> x);
266         void set(etl::handle<Canvas> x);
267         template <class T> void set(const std::vector<T> &x)
268                 { _set(list_type(x.begin(),x.end())); }
269         template <class T> void set(const std::list<T> &x)
270                 { _set(list_type(x.begin(),x.end())); }
271         // ========================================================================
272
273
274         /*
275  --     ** -- S T A T I C   F U N C T I O N S -------------------------------------
276         */
277
278 public:
279
280         //!     Returns a string containing the name of the given Type
281         static String type_name(Type id);
282
283         //!     Returns a string containing the translated name of the given Type
284         static String type_local_name(Type id);
285
286         //!     Returns a the corresponding Type of the described type
287         static Type ident_type(const String &str);
288
289
290         // === GET TYPE MEMBERS ===================================================
291         static Type get_type(bool) { return TYPE_BOOL; }
292         static Type get_type(int) { return TYPE_INTEGER; }
293         static Type get_type(const Time&) { return TYPE_TIME; }
294         static Type get_type(const Real&) { return TYPE_REAL; }
295         static Type get_type(const float&) { return TYPE_REAL; }
296         static Type get_type(const Vector&) { return TYPE_VECTOR; }
297         static Type get_type(const Color&) { return TYPE_COLOR; }
298         static Type get_type(const Segment&) { return TYPE_SEGMENT; }
299         static Type get_type(const BLinePoint&) { return TYPE_BLINEPOINT; }
300         static Type get_type(const String&) { return TYPE_STRING; }
301         static Type get_type(const Gradient&) { return TYPE_GRADIENT; }
302         static Type get_type(Canvas*) { return TYPE_CANVAS; }
303         static Type get_type(const etl::handle<Canvas>&)
304                 { return TYPE_CANVAS; }
305         static Type get_type(const etl::loose_handle<Canvas>&)
306                 { return TYPE_CANVAS; }
307         static Type get_type(const list_type&) { return TYPE_LIST; }
308         template <class T> static Type get_type(const std::vector<T> &/*x*/)
309                 { return TYPE_LIST; }
310         template <class T> static Type get_type(const std::list<T> &/*x*/)
311                 { return TYPE_LIST; }
312         // ========================================================================
313
314
315         /*
316  --     ** -- C A S T   O P E R A T O R S -----------------------------------------
317         */
318
319 public:
320
321         operator const list_type&()const { return get_list(); }
322         //operator const Color&()const { return get(Color()); }
323         //operator const Real&()const { return get(Real()); }
324         //operator const Time&()const { return get(Time()); }
325
326         operator const Vector&()const {  return get(Vector()); }
327         operator const BLinePoint&()const {  return get(BLinePoint()); }
328         //operator const int&()const {  return get(int()); }
329         //operator const String&()const {  return get(String()); }
330         //operator const char *()const {  return get(String()).c_str(); }
331         operator const Segment&()const { return get(Segment()); }
332
333
334         /*
335  --     ** -- O T H E R -----------------------------------------------------------
336         */
337
338 public:
339
340 #ifdef USE_HALF_TYPE
341         half get(const half &)const { return get(Real()); }
342         void put(half*x)const { *x=get(Real()); }
343         void set(const half &x) { _set(Real(x)); }
344         static Type get_type(const half&) { return TYPE_REAL; }
345         operator half()const { return get(Real()); }
346 #endif
347
348 #ifndef SYNFIG_NO_ANGLE
349         operator const Angle&()const { return get(Angle()); }
350         static Type get_type(const Angle&) { return TYPE_ANGLE; }
351 #endif
352
353         template <class T>
354         operator std::list<T>()const
355         {
356                 assert(type==TYPE_LIST);
357                 std::list<T> ret(get_list().begin(),get_list().end());
358                 return ret;
359         }
360         template <class T>
361         operator std::vector<T>()const
362         {
363                 assert(type==TYPE_LIST);
364                 std::vector<T> ret(get_list().begin(),get_list().end());
365                 return ret;
366         }
367
368
369 private:
370
371         template <typename T> void
372         _set(const T& x)
373         {
374                 const Type newtype(get_type(x));
375
376                 assert(newtype!=TYPE_NIL);
377
378                 if(newtype==type)
379                 {
380                         if(ref_count.unique())
381                         {
382                                 *reinterpret_cast<T*>(data)=x;
383                                 return;
384                         }
385                 }
386
387                 clear();
388
389                 type=newtype;
390                 ref_count.reset();
391                 data=new T(x);
392         }
393 }; // END of class ValueBase
394
395
396 /*!     \class Value
397 **      \todo writeme
398 */
399 template <class T>
400 class Value : public ValueBase
401 {
402 public:
403         Value(const T &x):ValueBase(x)
404         {
405         }
406
407         Value(const ValueBase &x):ValueBase(x)
408         {
409                 if(!x.same_type_as(T()))
410                         throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
411         }
412
413         Value()
414         {
415         }
416
417         T get()const { return ValueBase::get(T()); }
418
419         void put(T* x)const     { ValueBase::put(x); }
420
421         void set(const T& x) { ValueBase::operator=(x); }
422
423         Value<T>& operator=(const T& x) { set(x); return *this; }
424
425         Value<T>& operator=(const Value<T>& x) { return ValueBase::operator=(x); }
426
427         Value<T>& operator=(const ValueBase& x)
428         {
429                 if(!x.same_type_as(T()))
430                         throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
431                 return ValueBase::operator=(x);
432         }
433
434 }; // END of class Value
435
436 /*
437 template <>
438 class Value< std::list<CT> > : public ValueBase
439 {
440 public:
441         Value(const T &x):ValueBase(x)
442         {
443         }
444         Value(const ValueBase &x):ValueBase(x)
445         {
446                 if(!x.same_type_as(T()))
447                         throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
448         }
449         Value()
450         {
451         }
452
453         T get()const { return ValueBase::get(T()); }
454
455         void put(T* x)const     { ValueBase::put(x); }
456
457         void set(const T& x) { ValueBase::operator=(x); }
458
459         Value<T>& operator=(const T& x) { set(x); return *this; }
460
461         Value<T>& operator=(const Value<T>& x) { return ValueBase::operator=(x); }
462
463         Value<T>& operator=(const ValueBase& x)
464         {
465                 if(!x.same_type_as(T()))
466                         throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
467                 return ValueBase::operator=(x);
468         }
469
470 }; // END of class Value
471 */
472
473 }; // END of namespace synfig
474
475 /* === E N D =============================================================== */
476
477 #endif