1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxVariant class, container for any type
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_VARIANT_H_
13 #define _WX_VARIANT_H_
19 #include "wx/object.h"
20 #include "wx/string.h"
21 #include "wx/arrstr.h"
26 #include "wx/datetime.h"
27 #endif // wxUSE_DATETIME
29 #include "wx/iosfwrap.h"
32 * wxVariantData stores the actual data in a wxVariant object,
33 * to allow it to store any type of data.
34 * Derive from this to provide custom data handling.
36 * NB: To prevent addition of extra vtbl pointer to wxVariantData,
37 * we don't multiple-inherit from wxObjectRefData. Instead,
38 * we simply replicate the wxObject ref-counting scheme.
40 * NB: When you construct a wxVariantData, it will have refcount
41 * of one. Refcount will not be further increased when
42 * it is passed to wxVariant. This simulates old common
43 * scenario where wxVariant took ownership of wxVariantData
45 * If you create wxVariantData for other reasons than passing
46 * it to wxVariant, technically you are not required to call
47 * DecRef() before deleting it.
49 * TODO: in order to replace wxPropertyValue, we would need
50 * to consider adding constructors that take pointers to C++ variables,
51 * or removing that functionality from the wxProperty library.
52 * Essentially wxPropertyValue takes on some of the wxValidator functionality
53 * by storing pointers and not just actual values, allowing update of C++ data
54 * to be handled automatically. Perhaps there's another way of doing this without
55 * overloading wxVariant with unnecessary functionality.
58 class WXDLLIMPEXP_BASE wxVariantData
: public wxObjectRefData
60 friend class wxVariant
;
64 // Override these to provide common functionality
65 virtual bool Eq(wxVariantData
& data
) const = 0;
67 #if wxUSE_STD_IOSTREAM
68 virtual bool Write(wxSTD ostream
& WXUNUSED(str
)) const { return false; }
70 virtual bool Write(wxString
& WXUNUSED(str
)) const { return false; }
71 #if wxUSE_STD_IOSTREAM
72 virtual bool Read(wxSTD istream
& WXUNUSED(str
)) { return false; }
74 virtual bool Read(wxString
& WXUNUSED(str
)) { return false; }
75 // What type is it? Return a string name.
76 virtual wxString
GetType() const = 0;
77 // If it based on wxObject return the ClassInfo.
78 virtual wxClassInfo
* GetValueClassInfo() { return NULL
; }
80 // Implement this to make wxVariant::AllocExcusive work. Returns
81 // a copy of the data.
82 virtual wxVariantData
* Clone() const { return NULL
; }
85 // Protected dtor should make some incompatible code
86 // break more louder. That is, they should do data->DecRef()
87 // instead of delete data.
88 virtual ~wxVariantData() { }
92 * wxVariant can store any kind of data, but has some basic types
96 class WXDLLIMPEXP_FWD_BASE wxVariant
;
98 WX_DECLARE_LIST_WITH_DECL(wxVariant
, wxVariantList
, class WXDLLIMPEXP_BASE
);
100 class WXDLLIMPEXP_BASE wxVariant
: public wxObject
105 wxVariant(const wxVariant
& variant
);
106 wxVariant(wxVariantData
* data
, const wxString
& name
= wxEmptyString
);
107 virtual ~wxVariant();
109 // generic assignment
110 void operator= (const wxVariant
& variant
);
112 // Assignment using data, e.g.
113 // myVariant = new wxStringVariantData("hello");
114 void operator= (wxVariantData
* variantData
);
116 bool operator== (const wxVariant
& variant
) const;
117 bool operator!= (const wxVariant
& variant
) const;
120 inline void SetName(const wxString
& name
) { m_name
= name
; }
121 inline const wxString
& GetName() const { return m_name
; }
123 // Tests whether there is data
126 // For compatibility with wxWidgets <= 2.6, this doesn't increase
128 wxVariantData
* GetData() const { return m_data
; }
129 void SetData(wxVariantData
* data
) ;
131 // make a 'clone' of the object
132 void Ref(const wxVariant
& clone
);
134 // destroy a reference
137 // ensure that the data is exclusive to this variant, and not shared
140 // Make NULL (i.e. delete the data)
143 // Delete data and name
146 // Returns a string representing the type of the variant,
147 // e.g. "string", "bool", "stringlist", "list", "double", "long"
148 wxString
GetType() const;
150 bool IsType(const wxString
& type
) const;
151 bool IsValueKindOf(const wxClassInfo
* type
) const;
153 // write contents to a string (e.g. for debugging)
154 wxString
MakeString() const;
157 wxVariant(double val
, const wxString
& name
= wxEmptyString
);
158 bool operator== (double value
) const;
159 bool operator!= (double value
) const;
160 void operator= (double value
) ;
161 inline operator double () const { return GetDouble(); }
162 inline double GetReal() const { return GetDouble(); }
163 double GetDouble() const;
166 wxVariant(long val
, const wxString
& name
= wxEmptyString
);
167 wxVariant(int val
, const wxString
& name
= wxEmptyString
);
168 wxVariant(short val
, const wxString
& name
= wxEmptyString
);
169 bool operator== (long value
) const;
170 bool operator!= (long value
) const;
171 void operator= (long value
) ;
172 inline operator long () const { return GetLong(); }
173 inline long GetInteger() const { return GetLong(); }
174 long GetLong() const;
177 wxVariant(bool val
, const wxString
& name
= wxEmptyString
);
178 bool operator== (bool value
) const;
179 bool operator!= (bool value
) const;
180 void operator= (bool value
) ;
181 inline operator bool () const { return GetBool(); }
182 bool GetBool() const ;
186 wxVariant(const wxDateTime
& val
, const wxString
& name
= wxEmptyString
);
187 bool operator== (const wxDateTime
& value
) const;
188 bool operator!= (const wxDateTime
& value
) const;
189 void operator= (const wxDateTime
& value
) ;
190 inline operator wxDateTime () const { return GetDateTime(); }
191 wxDateTime
GetDateTime() const;
195 wxVariant(const wxString
& val
, const wxString
& name
= wxEmptyString
);
196 // these overloads are necessary to prevent the compiler from using bool
197 // version instead of wxString one:
198 wxVariant(const char* val
, const wxString
& name
= wxEmptyString
);
199 wxVariant(const wchar_t* val
, const wxString
& name
= wxEmptyString
);
200 wxVariant(const wxCStrData
& val
, const wxString
& name
= wxEmptyString
);
201 wxVariant(const wxScopedCharBuffer
& val
, const wxString
& name
= wxEmptyString
);
202 wxVariant(const wxScopedWCharBuffer
& val
, const wxString
& name
= wxEmptyString
);
204 bool operator== (const wxString
& value
) const;
205 bool operator!= (const wxString
& value
) const;
206 wxVariant
& operator=(const wxString
& value
);
207 // these overloads are necessary to prevent the compiler from using bool
208 // version instead of wxString one:
209 wxVariant
& operator=(const char* value
)
210 { return *this = wxString(value
); }
211 wxVariant
& operator=(const wchar_t* value
)
212 { return *this = wxString(value
); }
213 wxVariant
& operator=(const wxCStrData
& value
)
214 { return *this = value
.AsString(); }
216 wxVariant
& operator=(const wxScopedCharTypeBuffer
<T
>& value
)
217 { return *this = value
.data(); }
219 inline operator wxString () const { return MakeString(); }
220 wxString
GetString() const;
223 wxVariant(const wxUniChar
& val
, const wxString
& name
= wxEmptyString
);
224 wxVariant(const wxUniCharRef
& val
, const wxString
& name
= wxEmptyString
);
225 wxVariant(char val
, const wxString
& name
= wxEmptyString
);
226 wxVariant(wchar_t val
, const wxString
& name
= wxEmptyString
);
227 bool operator==(const wxUniChar
& value
) const;
228 bool operator==(const wxUniCharRef
& value
) const { return *this == wxUniChar(value
); }
229 bool operator==(char value
) const { return *this == wxUniChar(value
); }
230 bool operator==(wchar_t value
) const { return *this == wxUniChar(value
); }
231 bool operator!=(const wxUniChar
& value
) const { return !(*this == value
); }
232 bool operator!=(const wxUniCharRef
& value
) const { return !(*this == value
); }
233 bool operator!=(char value
) const { return !(*this == value
); }
234 bool operator!=(wchar_t value
) const { return !(*this == value
); }
235 wxVariant
& operator=(const wxUniChar
& value
);
236 wxVariant
& operator=(const wxUniCharRef
& value
) { return *this = wxUniChar(value
); }
237 wxVariant
& operator=(char value
) { return *this = wxUniChar(value
); }
238 wxVariant
& operator=(wchar_t value
) { return *this = wxUniChar(value
); }
239 operator wxUniChar() const { return GetChar(); }
240 operator char() const { return GetChar(); }
241 operator wchar_t() const { return GetChar(); }
242 wxUniChar
GetChar() const;
245 wxVariant(const wxArrayString
& val
, const wxString
& name
= wxEmptyString
);
246 bool operator== (const wxArrayString
& value
) const;
247 bool operator!= (const wxArrayString
& value
) const;
248 void operator= (const wxArrayString
& value
);
249 operator wxArrayString () const { return GetArrayString(); }
250 wxArrayString
GetArrayString() const;
253 wxVariant(void* ptr
, const wxString
& name
= wxEmptyString
);
254 bool operator== (void* value
) const;
255 bool operator!= (void* value
) const;
256 void operator= (void* value
);
257 operator void* () const { return GetVoidPtr(); }
258 void* GetVoidPtr() const;
261 wxVariant(wxObject
* ptr
, const wxString
& name
= wxEmptyString
);
262 bool operator== (wxObject
* value
) const;
263 bool operator!= (wxObject
* value
) const;
264 void operator= (wxObject
* value
);
265 wxObject
* GetWxObjectPtr() const;
268 // ------------------------------
270 // ------------------------------
272 wxVariant(const wxVariantList
& val
, const wxString
& name
= wxEmptyString
); // List of variants
273 bool operator== (const wxVariantList
& value
) const;
274 bool operator!= (const wxVariantList
& value
) const;
275 void operator= (const wxVariantList
& value
) ;
276 // Treat a list variant as an array
277 wxVariant
operator[] (size_t idx
) const;
278 wxVariant
& operator[] (size_t idx
) ;
279 wxVariantList
& GetList() const ;
281 // Return the number of elements in a list
282 size_t GetCount() const;
288 void Append(const wxVariant
& value
);
290 // Insert at front of list
291 void Insert(const wxVariant
& value
);
293 // Returns true if the variant is a member of the list
294 bool Member(const wxVariant
& value
) const;
296 // Deletes the nth element of the list
297 bool Delete(size_t item
);
304 bool Convert(long* value
) const;
305 bool Convert(bool* value
) const;
306 bool Convert(double* value
) const;
307 bool Convert(wxString
* value
) const;
308 bool Convert(wxUniChar
* value
) const;
309 bool Convert(char* value
) const;
310 bool Convert(wchar_t* value
) const;
312 bool Convert(wxDateTime
* value
) const;
313 #endif // wxUSE_DATETIME
317 wxVariantData
* m_data
;
321 DECLARE_DYNAMIC_CLASS(wxVariant
)
324 #define DECLARE_VARIANT_OBJECT(classname) \
325 DECLARE_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
327 #define DECLARE_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
328 expdecl classname& operator << ( classname &object, const wxVariant &variant ); \
329 expdecl wxVariant& operator << ( wxVariant &variant, const classname &object );
331 #define IMPLEMENT_VARIANT_OBJECT(classname) \
332 IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
334 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
335 class classname##VariantData: public wxVariantData \
338 classname##VariantData() {} \
339 classname##VariantData( const classname &value ) { m_value = value; } \
341 classname &GetValue() { return m_value; } \
343 virtual bool Eq(wxVariantData& data) const; \
345 virtual wxString GetType() const; \
346 virtual wxClassInfo* GetValueClassInfo(); \
348 virtual wxVariantData* Clone() const { return new classname##VariantData(m_value); } \
354 wxString classname##VariantData::GetType() const\
356 return m_value.GetClassInfo()->GetClassName();\
359 wxClassInfo* classname##VariantData::GetValueClassInfo()\
361 return m_value.GetClassInfo();\
364 expdecl classname& operator << ( classname &value, const wxVariant &variant )\
366 wxASSERT( variant.GetType() == #classname );\
368 classname##VariantData *data = (classname##VariantData*) variant.GetData();\
369 value = data->GetValue();\
373 expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
375 classname##VariantData *data = new classname##VariantData( value );\
376 variant.SetData( data );\
380 // implements a wxVariantData-derived class using for the Eq() method the
381 // operator== which must have been provided by "classname"
382 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
383 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
385 bool classname##VariantData::Eq(wxVariantData& data) const \
387 wxASSERT( GetType() == data.GetType() );\
389 classname##VariantData & otherData = (classname##VariantData &) data;\
391 return otherData.m_value == m_value;\
395 // implements a wxVariantData-derived class using for the Eq() method a shallow
396 // comparison (through wxObject::IsSameAs function)
397 #define IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(classname) \
398 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname, wxEMPTY_PARAMETER_VALUE)
399 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname,expdecl) \
400 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
402 bool classname##VariantData::Eq(wxVariantData& data) const \
404 wxASSERT( GetType() == data.GetType() );\
406 classname##VariantData & otherData = (classname##VariantData &) data;\
408 return (otherData.m_value.IsSameAs(m_value));\
412 // Since we want type safety wxVariant we need to fetch and dynamic_cast
413 // in a seemingly safe way so the compiler can check, so we define
414 // a dynamic_cast /wxDynamicCast analogue.
416 #define wxGetVariantCast(var,classname) \
417 ((classname*)(var.IsValueKindOf(&classname::ms_classInfo) ?\
418 var.GetWxObjectPtr() : NULL));
420 // Replacement for using wxDynamicCast on a wxVariantData object
421 #define wxDynamicCastVariantData(data, classname) dynamic_cast<classname*>(data)
423 extern wxVariant WXDLLIMPEXP_BASE wxNullVariant
;
425 #endif // wxUSE_VARIANT
427 #endif // _WX_VARIANT_H_