]> git.saurik.com Git - wxWidgets.git/blame - include/wx/variant.h
Removed redundant code
[wxWidgets.git] / include / wx / variant.h
CommitLineData
8cb50e4b 1/////////////////////////////////////////////////////////////////////////////
43f06cfd 2// Name: wx/variant.h
8cb50e4b
JS
3// Purpose: wxVariant class, container for any type
4// Author: Julian Smart
5// Modified by:
6// Created: 10/09/98
7// RCS-ID: $Id$
99d80019 8// Copyright: (c) Julian Smart
65571936 9// Licence: wxWindows licence
8cb50e4b
JS
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef _WX_VARIANT_H_
13#define _WX_VARIANT_H_
14
8cb50e4b 15#include "wx/defs.h"
d5dc103f
VZ
16
17#if wxUSE_VARIANT
18
8cb50e4b
JS
19#include "wx/object.h"
20#include "wx/string.h"
4c3ebca9 21#include "wx/arrstr.h"
8cb50e4b 22#include "wx/list.h"
bde626ce 23#include "wx/cpp.h"
8cb50e4b 24
e2b87f38
VZ
25#if wxUSE_DATETIME
26 #include "wx/datetime.h"
27#endif // wxUSE_DATETIME
edca7a82
GT
28
29#if wxUSE_ODBC
30 #include "wx/db.h" // will #include sqltypes.h
31#endif //ODBC
32
65f19af1 33#include "wx/iosfwrap.h"
8cb50e4b
JS
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 *
2562c823
RR
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 *
8cb50e4b
JS
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
bddd7a8d 62class WXDLLIMPEXP_BASE wxVariantData: public wxObject
8cb50e4b 63{
2562c823 64 friend class wxVariant;
8cb50e4b 65public:
2562c823
RR
66 wxVariantData()
67 : wxObject(), m_count(1)
68 { }
8cb50e4b 69
2562c823 70 // Override these to provide common functionality
8cb50e4b 71 virtual bool Eq(wxVariantData& data) const = 0;
07502d73 72
38830220 73#if wxUSE_STD_IOSTREAM
07502d73 74 virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }
38830220 75#endif
07502d73 76 virtual bool Write(wxString& WXUNUSED(str)) const { return false; }
38830220 77#if wxUSE_STD_IOSTREAM
07502d73 78 virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
38830220 79#endif
07502d73 80 virtual bool Read(wxString& WXUNUSED(str)) { return false; }
8cb50e4b
JS
81 // What type is it? Return a string name.
82 virtual wxString GetType() const = 0;
cf6ae290
RG
83 // If it based on wxObject return the ClassInfo.
84 virtual wxClassInfo* GetValueClassInfo() { return NULL; }
2562c823
RR
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
95protected:
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
101private:
102 int m_count;
07502d73 103
2562c823
RR
104private:
105 DECLARE_ABSTRACT_CLASS(wxVariantData)
8cb50e4b
JS
106};
107
108/*
109 * wxVariant can store any kind of data, but has some basic types
110 * built in.
8cb50e4b
JS
111 */
112
bddd7a8d 113class WXDLLIMPEXP_BASE wxVariant: public wxObject
8cb50e4b 114{
8cb50e4b 115public:
8cb50e4b 116 wxVariant();
07502d73 117
8cb50e4b 118 wxVariant(const wxVariant& variant);
2562c823 119 wxVariant(wxVariantData* data, const wxString& name = wxEmptyString);
d3c7fc99 120 virtual ~wxVariant();
8cb50e4b 121
2562c823 122 // generic assignment
8cb50e4b
JS
123 void operator= (const wxVariant& variant);
124
125 // Assignment using data, e.g.
126 // myVariant = new wxStringVariantData("hello");
127 void operator= (wxVariantData* variantData);
07502d73 128
8cb50e4b
JS
129 bool operator== (const wxVariant& variant) const;
130 bool operator!= (const wxVariant& variant) const;
131
2562c823
RR
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
07502d73 137 bool IsNull() const;
2562c823
RR
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();
07502d73 152
2562c823
RR
153 // Delete data and name
154 void Clear();
07502d73 155
2562c823
RR
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
07502d73 163 // write contents to a string (e.g. for debugging)
2562c823 164 wxString MakeString() const;
07502d73 165
2562c823
RR
166 // double
167 wxVariant(double val, const wxString& name = wxEmptyString);
8cb50e4b
JS
168 bool operator== (double value) const;
169 bool operator!= (double value) const;
170 void operator= (double value) ;
2562c823
RR
171 inline operator double () const { return GetDouble(); }
172 inline double GetReal() const { return GetDouble(); }
173 double GetDouble() const;
07502d73 174
2562c823
RR
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);
8cb50e4b
JS
179 bool operator== (long value) const;
180 bool operator!= (long value) const;
181 void operator= (long value) ;
2562c823
RR
182 inline operator long () const { return GetLong(); }
183 inline long GetInteger() const { return GetLong(); }
184 long GetLong() const;
07502d73
WS
185
186 // bool
57493f9f 187#ifdef HAVE_BOOL
2562c823 188 wxVariant(bool val, const wxString& name = wxEmptyString);
8cb50e4b
JS
189 bool operator== (bool value) const;
190 bool operator!= (bool value) const;
191 void operator= (bool value) ;
2562c823
RR
192 inline operator bool () const { return GetBool(); }
193 bool GetBool() const ;
194#endif
195
196 // wxDateTime
197#if wxUSE_DATETIME
07502d73 198 wxVariant(const wxDateTime& val, const wxString& name = wxEmptyString);
2562c823
RR
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;
57493f9f 214#endif
2562c823
RR
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!
8cb50e4b
JS
219 bool operator== (const wxString& value) const;
220 bool operator!= (const wxString& value) const;
221 void operator= (const wxString& value) ;
2ed57eb7 222 void operator= (const wxChar* value) ; // Necessary or VC++ assumes bool!
2562c823
RR
223 inline operator wxString () const { return MakeString(); }
224 wxString GetString() const;
225
71520754
RR
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 ;
07502d73 233
2562c823
RR
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
2c3a1064 258#if WXWIN_COMPATIBILITY_2_4
2562c823 259 wxDEPRECATED( wxVariant(const wxStringList& val, const wxString& name = wxEmptyString) );
2c3a1064
RN
260 wxDEPRECATED( bool operator== (const wxStringList& value) const );
261 wxDEPRECATED( bool operator!= (const wxStringList& value) const );
262 wxDEPRECATED( void operator= (const wxStringList& value) );
2562c823 263 wxDEPRECATED( wxStringList& GetStringList() const );
2c3a1064 264#endif
2562c823
RR
265
266 // ------------------------------
267 // list operations
268 // ------------------------------
269
270 wxVariant(const wxList& val, const wxString& name = wxEmptyString); // List of variants
8cb50e4b
JS
271 bool operator== (const wxList& value) const;
272 bool operator!= (const wxList& value) const;
273 void operator= (const wxList& value) ;
8cb50e4b
JS
274 // Treat a list variant as an array
275 wxVariant operator[] (size_t idx) const;
276 wxVariant& operator[] (size_t idx) ;
2562c823 277 wxList& GetList() const ;
8cb50e4b
JS
278
279 // Return the number of elements in a list
43f06cfd 280 size_t GetCount() const;
07502d73 281
8cb50e4b
JS
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
cab1a605 291 // Returns true if the variant is a member of the list
8cb50e4b
JS
292 bool Member(const wxVariant& value) const;
293
294 // Deletes the nth element of the list
43f06cfd 295 bool Delete(size_t item);
8cb50e4b
JS
296
297 // Clear list
298 void ClearList();
299
9708db20 300public:
2562c823 301 // Type conversion
8cb50e4b
JS
302 bool Convert(long* value) const;
303 bool Convert(bool* value) const;
304 bool Convert(double* value) const;
305 bool Convert(wxString* value) const;
38f82bf6 306 bool Convert(wxChar* value) const;
e2b87f38 307#if wxUSE_DATETIME
edca7a82 308 bool Convert(wxDateTime* value) const;
e2b87f38 309#endif // wxUSE_DATETIME
8cb50e4b
JS
310
311// Attributes
312protected:
313 wxVariantData* m_data;
a0a302dc 314 wxString m_name;
07502d73 315
2562c823
RR
316private:
317 DECLARE_DYNAMIC_CLASS(wxVariant)
8cb50e4b
JS
318};
319
3f90a399 320#define DECLARE_VARIANT_OBJECT(classname) \
bde626ce 321 DECLARE_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
07502d73 322
6f5d7825 323#define DECLARE_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
39a48551
VZ
324expdecl classname& operator << ( classname &object, const wxVariant &variant ); \
325expdecl wxVariant& operator << ( wxVariant &variant, const classname &object );
3f90a399
RR
326
327#define IMPLEMENT_VARIANT_OBJECT(classname) \
bde626ce 328 IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
6f5d7825 329
55ccdb93 330#define IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
3f90a399
RR
331class classname##VariantData: public wxVariantData \
332{ \
333public:\
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\
344protected:\
345 classname m_value; \
346\
347private: \
348 DECLARE_CLASS(classname##VariantData) \
349};\
350\
351IMPLEMENT_CLASS(classname##VariantData, wxVariantData)\
352\
3f90a399
RR
353wxString classname##VariantData::GetType() const\
354{\
355 return m_value.GetClassInfo()->GetClassName();\
356}\
357\
358wxClassInfo* classname##VariantData::GetValueClassInfo()\
359{\
360 return m_value.GetClassInfo();\
361}\
362\
39a48551 363expdecl classname& operator << ( classname &value, const wxVariant &variant )\
3f90a399
RR
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\
39a48551 372expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
3f90a399
RR
373{\
374 classname##VariantData *data = new classname##VariantData( value );\
375 variant.SetData( data );\
376 return variant;\
377}
378
01df01eb
VZ
379// implements a wxVariantData-derived class using for the Eq() method the
380// operator== which must have been provided by "classname"
55ccdb93 381#define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
5ffa72f4 382IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
55ccdb93
VZ
383\
384bool 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
a3ab1c18 395// comparison (through wxObject::IsSameAs function)
01df01eb
VZ
396#define IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(classname) \
397 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname, wxEMPTY_PARAMETER_VALUE)
55ccdb93 398#define IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname,expdecl) \
5ffa72f4 399IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
55ccdb93
VZ
400\
401bool classname##VariantData::Eq(wxVariantData& data) const \
402{\
403 wxASSERT( wxIsKindOf((&data), classname##VariantData) );\
404\
405 classname##VariantData & otherData = (classname##VariantData &) data;\
406\
a3ab1c18 407 return (otherData.m_value.IsSameAs(m_value));\
55ccdb93
VZ
408}\
409
410
3f90a399
RR
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.
cf6ae290
RG
414
415#define wxGetVariantCast(var,classname) \
cab1a605
WS
416 ((classname*)(var.IsValueKindOf(&classname::ms_classInfo) ?\
417 var.GetWxObjectPtr() : NULL));
cf6ae290 418
bddd7a8d 419extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;
a0a302dc 420
d5dc103f
VZ
421#endif // wxUSE_VARIANT
422
423#endif // _WX_VARIANT_H_