/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/include/wx/variant.h
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/include/wx/variant.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 10 - (show annotations) (download)
Mon Sep 6 11:40:06 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 14306 byte(s)
exported r3113 from ./upstream/trunk
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/variant.h
3 // Purpose: wxVariant class, container for any type
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 10/09/98
7 // RCS-ID: $Id: variant.h 42997 2006-11-03 21:37:08Z VZ $
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_VARIANT_H_
13 #define _WX_VARIANT_H_
14
15 #include "wx/defs.h"
16
17 #if wxUSE_VARIANT
18
19 #include "wx/object.h"
20 #include "wx/string.h"
21 #include "wx/arrstr.h"
22 #include "wx/list.h"
23 #include "wx/cpp.h"
24
25 #if wxUSE_DATETIME
26 #include "wx/datetime.h"
27 #endif // wxUSE_DATETIME
28
29 #if wxUSE_ODBC
30 #include "wx/db.h" // will #include sqltypes.h
31 #endif //ODBC
32
33 #include "wx/iosfwrap.h"
34
35 /*
36 * wxVariantData stores the actual data in a wxVariant object,
37 * to allow it to store any type of data.
38 * Derive from this to provide custom data handling.
39 *
40 * NB: To prevent addition of extra vtbl pointer to wxVariantData,
41 * we don't multiple-inherit from wxObjectRefData. Instead,
42 * we simply replicate the wxObject ref-counting scheme.
43 *
44 * NB: When you construct a wxVariantData, it will have refcount
45 * of one. Refcount will not be further increased when
46 * it is passed to wxVariant. This simulates old common
47 * scenario where wxVariant took ownership of wxVariantData
48 * passed to it.
49 * If you create wxVariantData for other reasons than passing
50 * it to wxVariant, technically you are not required to call
51 * DecRef() before deleting it.
52 *
53 * TODO: in order to replace wxPropertyValue, we would need
54 * to consider adding constructors that take pointers to C++ variables,
55 * or removing that functionality from the wxProperty library.
56 * Essentially wxPropertyValue takes on some of the wxValidator functionality
57 * by storing pointers and not just actual values, allowing update of C++ data
58 * to be handled automatically. Perhaps there's another way of doing this without
59 * overloading wxVariant with unnecessary functionality.
60 */
61
62 class WXDLLIMPEXP_BASE wxVariantData: public wxObject
63 {
64 friend class wxVariant;
65 public:
66 wxVariantData()
67 : wxObject(), m_count(1)
68 { }
69
70 // Override these to provide common functionality
71 virtual bool Eq(wxVariantData& data) const = 0;
72
73 #if wxUSE_STD_IOSTREAM
74 virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }
75 #endif
76 virtual bool Write(wxString& WXUNUSED(str)) const { return false; }
77 #if wxUSE_STD_IOSTREAM
78 virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
79 #endif
80 virtual bool Read(wxString& WXUNUSED(str)) { return false; }
81 // What type is it? Return a string name.
82 virtual wxString GetType() const = 0;
83 // If it based on wxObject return the ClassInfo.
84 virtual wxClassInfo* GetValueClassInfo() { return NULL; }
85
86 void IncRef() { m_count++; }
87 void DecRef()
88 {
89 if ( --m_count == 0 )
90 delete this;
91 }
92
93 int GetRefCount() const { return m_count; }
94
95 protected:
96 // Protected dtor should make some incompatible code
97 // break more louder. That is, they should do data->DecRef()
98 // instead of delete data.
99 virtual ~wxVariantData() { }
100
101 private:
102 int m_count;
103
104 private:
105 DECLARE_ABSTRACT_CLASS(wxVariantData)
106 };
107
108 /*
109 * wxVariant can store any kind of data, but has some basic types
110 * built in.
111 */
112
113 class WXDLLIMPEXP_BASE wxVariant: public wxObject
114 {
115 public:
116 wxVariant();
117
118 wxVariant(const wxVariant& variant);
119 wxVariant(wxVariantData* data, const wxString& name = wxEmptyString);
120 virtual ~wxVariant();
121
122 // generic assignment
123 void operator= (const wxVariant& variant);
124
125 // Assignment using data, e.g.
126 // myVariant = new wxStringVariantData("hello");
127 void operator= (wxVariantData* variantData);
128
129 bool operator== (const wxVariant& variant) const;
130 bool operator!= (const wxVariant& variant) const;
131
132 // Sets/gets name
133 inline void SetName(const wxString& name) { m_name = name; }
134 inline const wxString& GetName() const { return m_name; }
135
136 // Tests whether there is data
137 bool IsNull() const;
138
139 // For compatibility with wxWidgets <= 2.6, this doesn't increase
140 // reference count.
141 wxVariantData* GetData() const { return m_data; }
142 void SetData(wxVariantData* data) ;
143
144 // make a 'clone' of the object
145 void Ref(const wxVariant& clone);
146
147 // destroy a reference
148 void UnRef();
149
150 // Make NULL (i.e. delete the data)
151 void MakeNull();
152
153 // Delete data and name
154 void Clear();
155
156 // Returns a string representing the type of the variant,
157 // e.g. "string", "bool", "stringlist", "list", "double", "long"
158 wxString GetType() const;
159
160 bool IsType(const wxString& type) const;
161 bool IsValueKindOf(const wxClassInfo* type) const;
162
163 // write contents to a string (e.g. for debugging)
164 wxString MakeString() const;
165
166 // double
167 wxVariant(double val, const wxString& name = wxEmptyString);
168 bool operator== (double value) const;
169 bool operator!= (double value) const;
170 void operator= (double value) ;
171 inline operator double () const { return GetDouble(); }
172 inline double GetReal() const { return GetDouble(); }
173 double GetDouble() const;
174
175 // long
176 wxVariant(long val, const wxString& name = wxEmptyString);
177 wxVariant(int val, const wxString& name = wxEmptyString);
178 wxVariant(short val, const wxString& name = wxEmptyString);
179 bool operator== (long value) const;
180 bool operator!= (long value) const;
181 void operator= (long value) ;
182 inline operator long () const { return GetLong(); }
183 inline long GetInteger() const { return GetLong(); }
184 long GetLong() const;
185
186 // bool
187 #ifdef HAVE_BOOL
188 wxVariant(bool val, const wxString& name = wxEmptyString);
189 bool operator== (bool value) const;
190 bool operator!= (bool value) const;
191 void operator= (bool value) ;
192 inline operator bool () const { return GetBool(); }
193 bool GetBool() const ;
194 #endif
195
196 // wxDateTime
197 #if wxUSE_DATETIME
198 wxVariant(const wxDateTime& val, const wxString& name = wxEmptyString);
199 #if wxUSE_ODBC
200 wxVariant(const DATE_STRUCT* valptr, const wxString& name = wxEmptyString);
201 wxVariant(const TIME_STRUCT* valptr, const wxString& name = wxEmptyString);
202 wxVariant(const TIMESTAMP_STRUCT* valptr, const wxString& name = wxEmptyString);
203 #endif
204 bool operator== (const wxDateTime& value) const;
205 bool operator!= (const wxDateTime& value) const;
206 void operator= (const wxDateTime& value) ;
207 #if wxUSE_ODBC
208 void operator= (const DATE_STRUCT* value) ;
209 void operator= (const TIME_STRUCT* value) ;
210 void operator= (const TIMESTAMP_STRUCT* value) ;
211 #endif
212 inline operator wxDateTime () const { return GetDateTime(); }
213 wxDateTime GetDateTime() const;
214 #endif
215
216 // wxString
217 wxVariant(const wxString& val, const wxString& name = wxEmptyString);
218 wxVariant(const wxChar* val, const wxString& name = wxEmptyString); // Necessary or VC++ assumes bool!
219 bool operator== (const wxString& value) const;
220 bool operator!= (const wxString& value) const;
221 void operator= (const wxString& value) ;
222 void operator= (const wxChar* value) ; // Necessary or VC++ assumes bool!
223 inline operator wxString () const { return MakeString(); }
224 wxString GetString() const;
225
226 // wxChar
227 wxVariant(wxChar val, const wxString& name = wxEmptyString);
228 bool operator== (wxChar value) const;
229 bool operator!= (wxChar value) const;
230 void operator= (wxChar value) ;
231 inline operator wxChar () const { return GetChar(); }
232 wxChar GetChar() const ;
233
234 // wxArrayString
235 wxVariant(const wxArrayString& val, const wxString& name = wxEmptyString);
236 bool operator== (const wxArrayString& value) const;
237 bool operator!= (const wxArrayString& value) const;
238 void operator= (const wxArrayString& value);
239 inline operator wxArrayString () const { return GetArrayString(); }
240 wxArrayString GetArrayString() const;
241
242 // void*
243 wxVariant(void* ptr, const wxString& name = wxEmptyString);
244 bool operator== (void* value) const;
245 bool operator!= (void* value) const;
246 void operator= (void* value);
247 inline operator void* () const { return GetVoidPtr(); }
248 void* GetVoidPtr() const;
249
250 // wxObject*
251 wxVariant(wxObject* ptr, const wxString& name = wxEmptyString);
252 bool operator== (wxObject* value) const;
253 bool operator!= (wxObject* value) const;
254 void operator= (wxObject* value);
255 wxObject* GetWxObjectPtr() const;
256
257
258 #if WXWIN_COMPATIBILITY_2_4
259 wxDEPRECATED( wxVariant(const wxStringList& val, const wxString& name = wxEmptyString) );
260 wxDEPRECATED( bool operator== (const wxStringList& value) const );
261 wxDEPRECATED( bool operator!= (const wxStringList& value) const );
262 wxDEPRECATED( void operator= (const wxStringList& value) );
263 wxDEPRECATED( wxStringList& GetStringList() const );
264 #endif
265
266 // ------------------------------
267 // list operations
268 // ------------------------------
269
270 wxVariant(const wxList& val, const wxString& name = wxEmptyString); // List of variants
271 bool operator== (const wxList& value) const;
272 bool operator!= (const wxList& value) const;
273 void operator= (const wxList& value) ;
274 // Treat a list variant as an array
275 wxVariant operator[] (size_t idx) const;
276 wxVariant& operator[] (size_t idx) ;
277 wxList& GetList() const ;
278
279 // Return the number of elements in a list
280 size_t GetCount() const;
281
282 // Make empty list
283 void NullList();
284
285 // Append to list
286 void Append(const wxVariant& value);
287
288 // Insert at front of list
289 void Insert(const wxVariant& value);
290
291 // Returns true if the variant is a member of the list
292 bool Member(const wxVariant& value) const;
293
294 // Deletes the nth element of the list
295 bool Delete(size_t item);
296
297 // Clear list
298 void ClearList();
299
300 public:
301 // Type conversion
302 bool Convert(long* value) const;
303 bool Convert(bool* value) const;
304 bool Convert(double* value) const;
305 bool Convert(wxString* value) const;
306 bool Convert(wxChar* value) const;
307 #if wxUSE_DATETIME
308 bool Convert(wxDateTime* value) const;
309 #endif // wxUSE_DATETIME
310
311 // Attributes
312 protected:
313 wxVariantData* m_data;
314 wxString m_name;
315
316 private:
317 DECLARE_DYNAMIC_CLASS(wxVariant)
318 };
319
320 #define DECLARE_VARIANT_OBJECT(classname) \
321 DECLARE_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
322
323 #define DECLARE_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
324 expdecl classname& operator << ( classname &object, const wxVariant &variant ); \
325 expdecl wxVariant& operator << ( wxVariant &variant, const classname &object );
326
327 #define IMPLEMENT_VARIANT_OBJECT(classname) \
328 IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
329
330 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
331 class classname##VariantData: public wxVariantData \
332 { \
333 public:\
334 classname##VariantData() {} \
335 classname##VariantData( const classname &value ) { m_value = value; } \
336 \
337 classname &GetValue() { return m_value; } \
338 \
339 virtual bool Eq(wxVariantData& data) const; \
340 \
341 virtual wxString GetType() const; \
342 virtual wxClassInfo* GetValueClassInfo(); \
343 \
344 protected:\
345 classname m_value; \
346 \
347 private: \
348 DECLARE_CLASS(classname##VariantData) \
349 };\
350 \
351 IMPLEMENT_CLASS(classname##VariantData, wxVariantData)\
352 \
353 wxString classname##VariantData::GetType() const\
354 {\
355 return m_value.GetClassInfo()->GetClassName();\
356 }\
357 \
358 wxClassInfo* classname##VariantData::GetValueClassInfo()\
359 {\
360 return m_value.GetClassInfo();\
361 }\
362 \
363 expdecl classname& operator << ( classname &value, const wxVariant &variant )\
364 {\
365 wxASSERT( wxIsKindOf( variant.GetData(), classname##VariantData ) );\
366 \
367 classname##VariantData *data = (classname##VariantData*) variant.GetData();\
368 value = data->GetValue();\
369 return value;\
370 }\
371 \
372 expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
373 {\
374 classname##VariantData *data = new classname##VariantData( value );\
375 variant.SetData( data );\
376 return variant;\
377 }
378
379 // implements a wxVariantData-derived class using for the Eq() method the
380 // operator== which must have been provided by "classname"
381 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
382 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
383 \
384 bool classname##VariantData::Eq(wxVariantData& data) const \
385 {\
386 wxASSERT( wxIsKindOf((&data), classname##VariantData) );\
387 \
388 classname##VariantData & otherData = (classname##VariantData &) data;\
389 \
390 return otherData.m_value == m_value;\
391 }\
392
393
394 // implements a wxVariantData-derived class using for the Eq() method a shallow
395 // comparison (through wxObject::IsSameAs function)
396 #define IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(classname) \
397 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname, wxEMPTY_PARAMETER_VALUE)
398 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname,expdecl) \
399 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
400 \
401 bool classname##VariantData::Eq(wxVariantData& data) const \
402 {\
403 wxASSERT( wxIsKindOf((&data), classname##VariantData) );\
404 \
405 classname##VariantData & otherData = (classname##VariantData &) data;\
406 \
407 return (otherData.m_value.IsSameAs(m_value));\
408 }\
409
410
411 // Since we want type safety wxVariant we need to fetch and dynamic_cast
412 // in a seemingly safe way so the compiler can check, so we define
413 // a dynamic_cast /wxDynamicCast analogue.
414
415 #define wxGetVariantCast(var,classname) \
416 ((classname*)(var.IsValueKindOf(&classname::ms_classInfo) ?\
417 var.GetWxObjectPtr() : NULL));
418
419 extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;
420
421 #endif // wxUSE_VARIANT
422
423 #endif // _WX_VARIANT_H_

  ViewVC Help
Powered by ViewVC 1.1.22