include/wx/variant.h

   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$
   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 #include "wx/longlong.h"
  25
  26 #if wxUSE_DATETIME
  27     #include "wx/datetime.h"
  28 #endif // wxUSE_DATETIME
  29
  30 #include "wx/iosfwrap.h"
  31
  32 class wxAny;
  33
  34 /*
  35  * wxVariantData stores the actual data in a wxVariant object,
  36  * to allow it to store any type of data.
  37  * Derive from this to provide custom data handling.
  38  *
  39  * NB: When you construct a wxVariantData, it will have refcount
  40  *     of one. Refcount will not be further increased when
  41  *     it is passed to wxVariant. This simulates old common
  42  *     scenario where wxVariant took ownership of wxVariantData
  43  *     passed to it.
  44  *     If you create wxVariantData for other reasons than passing
  45  *     it to wxVariant, technically you are not required to call
  46  *     DecRef() before deleting it.
  47  *
  48  * TODO: in order to replace wxPropertyValue, we would need
  49  * to consider adding constructors that take pointers to C++ variables,
  50  * or removing that functionality from the wxProperty library.
  51  * Essentially wxPropertyValue takes on some of the wxValidator functionality
  52  * by storing pointers and not just actual values, allowing update of C++ data
  53  * to be handled automatically. Perhaps there's another way of doing this without
  54  * overloading wxVariant with unnecessary functionality.
  55  */
  56
  57 class WXDLLIMPEXP_BASE wxVariantData : public wxObjectRefData
  58 {
  59     friend class wxVariant;
  60 public:
  61     wxVariantData() { }
  62
  63     // Override these to provide common functionality
  64     virtual bool Eq(wxVariantData& data) const = 0;
  65
  66 #if wxUSE_STD_IOSTREAM
  67     virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }
  68 #endif
  69     virtual bool Write(wxString& WXUNUSED(str)) const { return false; }
  70 #if wxUSE_STD_IOSTREAM
  71     virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
  72 #endif
  73     virtual bool Read(wxString& WXUNUSED(str)) { return false; }
  74     // What type is it? Return a string name.
  75     virtual wxString GetType() const = 0;
  76     // If it based on wxObject return the ClassInfo.
  77     virtual wxClassInfo* GetValueClassInfo() { return NULL; }
  78
  79     // Implement this to make wxVariant::UnShare work. Returns
  80     // a copy of the data.
  81     virtual wxVariantData* Clone() const { return NULL; }
  82
  83 #if wxUSE_ANY
  84     // Converts value to wxAny, if possible. Return true if successful.
  85     virtual bool GetAsAny(wxAny* WXUNUSED(any)) const { return false; }
  86 #endif
  87
  88 protected:
  89     // Protected dtor should make some incompatible code
  90     // break more louder. That is, they should do data->DecRef()
  91     // instead of delete data.
  92     virtual ~wxVariantData() { }
  93 };
  94
  95 /*
  96  * wxVariant can store any kind of data, but has some basic types
  97  * built in.
  98  */
  99
 100 class WXDLLIMPEXP_FWD_BASE wxVariant;
 101
 102 WX_DECLARE_LIST_WITH_DECL(wxVariant, wxVariantList, class WXDLLIMPEXP_BASE);
 103
 104 class WXDLLIMPEXP_BASE wxVariant: public wxObject
 105 {
 106 public:
 107     wxVariant();
 108
 109     wxVariant(const wxVariant& variant);
 110     wxVariant(wxVariantData* data, const wxString& name = wxEmptyString);
 111 #if wxUSE_ANY
 112     wxVariant(const wxAny& any);
 113 #endif
 114     virtual ~wxVariant();
 115
 116     // generic assignment
 117     void operator= (const wxVariant& variant);
 118
 119     // Assignment using data, e.g.
 120     // myVariant = new wxStringVariantData("hello");
 121     void operator= (wxVariantData* variantData);
 122
 123     bool operator== (const wxVariant& variant) const;
 124     bool operator!= (const wxVariant& variant) const;
 125
 126     // Sets/gets name
 127     inline void SetName(const wxString& name) { m_name = name; }
 128     inline const wxString& GetName() const { return m_name; }
 129
 130     // Tests whether there is data
 131     bool IsNull() const;
 132
 133     // For compatibility with wxWidgets <= 2.6, this doesn't increase
 134     // reference count.
 135     wxVariantData* GetData() const
 136     {
 137         return (wxVariantData*) m_refData;
 138     }
 139     void SetData(wxVariantData* data) ;
 140
 141     // make a 'clone' of the object
 142     void Ref(const wxVariant& clone) { wxObject::Ref(clone); }
 143
 144     // ensure that the data is exclusive to this variant, and not shared
 145     bool Unshare();
 146
 147     // Make NULL (i.e. delete the data)
 148     void MakeNull();
 149
 150     // Delete data and name
 151     void Clear();
 152
 153     // Returns a string representing the type of the variant,
 154     // e.g. "string", "bool", "stringlist", "list", "double", "long"
 155     wxString GetType() const;
 156
 157     bool IsType(const wxString& type) const;
 158     bool IsValueKindOf(const wxClassInfo* type) const;
 159
 160     // write contents to a string (e.g. for debugging)
 161     wxString MakeString() const;
 162
 163 #if wxUSE_ANY
 164     wxAny GetAny() const;
 165 #endif
 166
 167     // double
 168     wxVariant(double val, const wxString& name = wxEmptyString);
 169     bool operator== (double value) const;
 170     bool operator!= (double value) const;
 171     void operator= (double value) ;
 172     inline operator double () const {  return GetDouble(); }
 173     inline double GetReal() const { return GetDouble(); }
 174     double GetDouble() const;
 175
 176     // long
 177     wxVariant(long val, const wxString& name = wxEmptyString);
 178     wxVariant(int val, const wxString& name = wxEmptyString);
 179     wxVariant(short val, const wxString& name = wxEmptyString);
 180     bool operator== (long value) const;
 181     bool operator!= (long value) const;
 182     void operator= (long value) ;
 183     inline operator long () const {  return GetLong(); }
 184     inline long GetInteger() const { return GetLong(); }
 185     long GetLong() const;
 186
 187     // 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
 195     // wxDateTime
 196 #if wxUSE_DATETIME
 197     wxVariant(const wxDateTime& val, const wxString& name = wxEmptyString);
 198     bool operator== (const wxDateTime& value) const;
 199     bool operator!= (const wxDateTime& value) const;
 200     void operator= (const wxDateTime& value) ;
 201     inline operator wxDateTime () const { return GetDateTime(); }
 202     wxDateTime GetDateTime() const;
 203 #endif
 204
 205     // wxString
 206     wxVariant(const wxString& val, const wxString& name = wxEmptyString);
 207     // these overloads are necessary to prevent the compiler from using bool
 208     // version instead of wxString one:
 209     wxVariant(const char* val, const wxString& name = wxEmptyString);
 210     wxVariant(const wchar_t* val, const wxString& name = wxEmptyString);
 211     wxVariant(const wxCStrData& val, const wxString& name = wxEmptyString);
 212     wxVariant(const wxScopedCharBuffer& val, const wxString& name = wxEmptyString);
 213     wxVariant(const wxScopedWCharBuffer& val, const wxString& name = wxEmptyString);
 214
 215     bool operator== (const wxString& value) const;
 216     bool operator!= (const wxString& value) const;
 217     wxVariant& operator=(const wxString& value);
 218     // these overloads are necessary to prevent the compiler from using bool
 219     // version instead of wxString one:
 220     wxVariant& operator=(const char* value)
 221         { return *this = wxString(value); }
 222     wxVariant& operator=(const wchar_t* value)
 223         { return *this = wxString(value); }
 224     wxVariant& operator=(const wxCStrData& value)
 225         { return *this = value.AsString(); }
 226     template<typename T>
 227     wxVariant& operator=(const wxScopedCharTypeBuffer<T>& value)
 228         { return *this = value.data(); }
 229
 230     inline operator wxString () const {  return MakeString(); }
 231     wxString GetString() const;
 232
 233 #if wxUSE_STD_STRING
 234     wxVariant(const std::string& val, const wxString& name = wxEmptyString);
 235     bool operator==(const std::string& value) const
 236         { return operator==(wxString(value)); }
 237     bool operator!=(const std::string& value) const
 238         { return operator!=(wxString(value)); }
 239     wxVariant& operator=(const std::string& value)
 240         { return operator=(wxString(value)); }
 241     operator std::string() const { return (operator wxString()).ToStdString(); }
 242
 243     wxVariant(const wxStdWideString& val, const wxString& name = wxEmptyString);
 244     bool operator==(const wxStdWideString& value) const
 245         { return operator==(wxString(value)); }
 246     bool operator!=(const wxStdWideString& value) const
 247         { return operator!=(wxString(value)); }
 248     wxVariant& operator=(const wxStdWideString& value)
 249         { return operator=(wxString(value)); }
 250     operator wxStdWideString() const { return (operator wxString()).ToStdWstring(); }
 251 #endif // wxUSE_STD_STRING
 252
 253     // wxUniChar
 254     wxVariant(const wxUniChar& val, const wxString& name = wxEmptyString);
 255     wxVariant(const wxUniCharRef& val, const wxString& name = wxEmptyString);
 256     wxVariant(char val, const wxString& name = wxEmptyString);
 257     wxVariant(wchar_t val, const wxString& name = wxEmptyString);
 258     bool operator==(const wxUniChar& value) const;
 259     bool operator==(const wxUniCharRef& value) const { return *this == wxUniChar(value); }
 260     bool operator==(char value) const { return *this == wxUniChar(value); }
 261     bool operator==(wchar_t value) const { return *this == wxUniChar(value); }
 262     bool operator!=(const wxUniChar& value) const { return !(*this == value); }
 263     bool operator!=(const wxUniCharRef& value) const { return !(*this == value); }
 264     bool operator!=(char value) const { return !(*this == value); }
 265     bool operator!=(wchar_t value) const { return !(*this == value); }
 266     wxVariant& operator=(const wxUniChar& value);
 267     wxVariant& operator=(const wxUniCharRef& value) { return *this = wxUniChar(value); }
 268     wxVariant& operator=(char value) { return *this = wxUniChar(value); }
 269     wxVariant& operator=(wchar_t value) { return *this = wxUniChar(value); }
 270     operator wxUniChar() const { return GetChar(); }
 271     operator char() const { return GetChar(); }
 272     operator wchar_t() const { return GetChar(); }
 273     wxUniChar GetChar() const;
 274
 275     // wxArrayString
 276     wxVariant(const wxArrayString& val, const wxString& name = wxEmptyString);
 277     bool operator== (const wxArrayString& value) const;
 278     bool operator!= (const wxArrayString& value) const;
 279     void operator= (const wxArrayString& value);
 280     operator wxArrayString () const { return GetArrayString(); }
 281     wxArrayString GetArrayString() const;
 282
 283     // void*
 284     wxVariant(void* ptr, const wxString& name = wxEmptyString);
 285     bool operator== (void* value) const;
 286     bool operator!= (void* value) const;
 287     void operator= (void* value);
 288     operator void* () const {  return GetVoidPtr(); }
 289     void* GetVoidPtr() const;
 290
 291     // wxObject*
 292     wxVariant(wxObject* ptr, const wxString& name = wxEmptyString);
 293     bool operator== (wxObject* value) const;
 294     bool operator!= (wxObject* value) const;
 295     void operator= (wxObject* value);
 296     wxObject* GetWxObjectPtr() const;
 297
 298 #if wxUSE_LONGLONG
 299     // wxLongLong
 300     wxVariant(wxLongLong, const wxString& name = wxEmptyString);
 301     bool operator==(wxLongLong value) const;
 302     bool operator!=(wxLongLong value) const;
 303     void operator=(wxLongLong value);
 304     operator wxLongLong() const { return GetLongLong(); }
 305     wxLongLong GetLongLong() const;
 306
 307     // wxULongLong
 308     wxVariant(wxULongLong, const wxString& name = wxEmptyString);
 309     bool operator==(wxULongLong value) const;
 310     bool operator!=(wxULongLong value) const;
 311     void operator=(wxULongLong value);
 312     operator wxULongLong() const { return GetULongLong(); }
 313     wxULongLong GetULongLong() const;
 314 #endif
 315
 316     // ------------------------------
 317     // list operations
 318     // ------------------------------
 319
 320     wxVariant(const wxVariantList& val, const wxString& name = wxEmptyString); // List of variants
 321     bool operator== (const wxVariantList& value) const;
 322     bool operator!= (const wxVariantList& value) const;
 323     void operator= (const wxVariantList& value) ;
 324     // Treat a list variant as an array
 325     wxVariant operator[] (size_t idx) const;
 326     wxVariant& operator[] (size_t idx) ;
 327     wxVariantList& GetList() const ;
 328
 329     // Return the number of elements in a list
 330     size_t GetCount() const;
 331
 332     // Make empty list
 333     void NullList();
 334
 335     // Append to list
 336     void Append(const wxVariant& value);
 337
 338     // Insert at front of list
 339     void Insert(const wxVariant& value);
 340
 341     // Returns true if the variant is a member of the list
 342     bool Member(const wxVariant& value) const;
 343
 344     // Deletes the nth element of the list
 345     bool Delete(size_t item);
 346
 347     // Clear list
 348     void ClearList();
 349
 350 public:
 351     // Type conversion
 352     bool Convert(long* value) const;
 353     bool Convert(bool* value) const;
 354     bool Convert(double* value) const;
 355     bool Convert(wxString* value) const;
 356     bool Convert(wxUniChar* value) const;
 357     bool Convert(char* value) const;
 358     bool Convert(wchar_t* value) const;
 359 #if wxUSE_DATETIME
 360     bool Convert(wxDateTime* value) const;
 361 #endif // wxUSE_DATETIME
 362 #if wxUSE_LONGLONG
 363     bool Convert(wxLongLong* value) const;
 364     bool Convert(wxULongLong* value) const;
 365 #endif // wxUSE_LONGLONG
 366
 367 // Attributes
 368 protected:
 369     virtual wxObjectRefData *CreateRefData() const;
 370     virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
 371
 372     wxString        m_name;
 373
 374 private:
 375     DECLARE_DYNAMIC_CLASS(wxVariant)
 376 };
 377
 378
 379 //
 380 // wxVariant <-> wxAny conversion code
 381 //
 382 #if wxUSE_ANY
 383
 384 #include "wx/any.h"
 385
 386 // In order to convert wxAny to wxVariant, we need to be able to associate
 387 // wxAnyValueType with a wxVariantData factory function.
 388 typedef wxVariantData* (*wxVariantDataFactory)(const wxAny& any);
 389
 390 // Actual Any-to-Variant registration must be postponed to a time when all
 391 // global variables have been initialized. Hence this arrangement.
 392 // wxAnyToVariantRegistration instances are kept in global scope and
 393 // wxAnyValueTypeGlobals in any.cpp will use their data when the time is
 394 // right.
 395 class WXDLLIMPEXP_BASE wxAnyToVariantRegistration
 396 {
 397 public:
 398     wxAnyToVariantRegistration(wxVariantDataFactory factory);
 399     virtual ~wxAnyToVariantRegistration();
 400
 401     virtual wxAnyValueType* GetAssociatedType() = 0;
 402     wxVariantDataFactory GetFactory() const { return m_factory; }
 403 private:
 404     wxVariantDataFactory    m_factory;
 405 };
 406
 407 template<typename T>
 408 class wxAnyToVariantRegistrationImpl : public wxAnyToVariantRegistration
 409 {
 410 public:
 411     wxAnyToVariantRegistrationImpl(wxVariantDataFactory factory)
 412         : wxAnyToVariantRegistration(factory)
 413     {
 414     }
 415
 416     virtual wxAnyValueType* GetAssociatedType()
 417     {
 418         return wxAnyValueTypeImpl<T>::GetInstance();
 419     }
 420 private:
 421 };
 422
 423 #define DECLARE_WXANY_CONVERSION() \
 424 virtual bool GetAsAny(wxAny* any) const; \
 425 static wxVariantData* VariantDataFactory(const wxAny& any);
 426
 427 #define _REGISTER_WXANY_CONVERSION(T, CLASSNAME, FUNC) \
 428 static wxAnyToVariantRegistrationImpl<T> \
 429     gs_##CLASSNAME##AnyToVariantRegistration = \
 430     wxAnyToVariantRegistrationImpl<T>(&FUNC);
 431
 432 #define REGISTER_WXANY_CONVERSION(T, CLASSNAME) \
 433 _REGISTER_WXANY_CONVERSION(T, CLASSNAME, CLASSNAME::VariantDataFactory)
 434
 435 #define IMPLEMENT_TRIVIAL_WXANY_CONVERSION(T, CLASSNAME) \
 436 bool CLASSNAME::GetAsAny(wxAny* any) const \
 437 { \
 438     *any = m_value; \
 439     return true; \
 440 } \
 441 wxVariantData* CLASSNAME::VariantDataFactory(const wxAny& any) \
 442 { \
 443     return new CLASSNAME(wxANY_AS(any, T)); \
 444 } \
 445 REGISTER_WXANY_CONVERSION(T, CLASSNAME)
 446
 447 // This is needed for wxVariantList conversion
 448 WX_DECLARE_LIST_WITH_DECL(wxAny, wxAnyList, class WXDLLIMPEXP_BASE);
 449
 450 #else // if !wxUSE_ANY
 451
 452 #define DECLARE_WXANY_CONVERSION()
 453 #define REGISTER_WXANY_CONVERSION(T, CLASSNAME)
 454 #define IMPLEMENT_TRIVIAL_WXANY_CONVERSION(T, CLASSNAME)
 455
 456 #endif // wxUSE_ANY/!wxUSE_ANY
 457
 458
 459 #define DECLARE_VARIANT_OBJECT(classname) \
 460     DECLARE_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
 461
 462 #define DECLARE_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
 463 expdecl classname& operator << ( classname &object, const wxVariant &variant ); \
 464 expdecl wxVariant& operator << ( wxVariant &variant, const classname &object );
 465
 466 #define IMPLEMENT_VARIANT_OBJECT(classname) \
 467     IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
 468
 469 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
 470 class classname##VariantData: public wxVariantData \
 471 { \
 472 public:\
 473     classname##VariantData() {} \
 474     classname##VariantData( const classname &value ) { m_value = value; } \
 475 \
 476     classname &GetValue() { return m_value; } \
 477 \
 478     virtual bool Eq(wxVariantData& data) const; \
 479 \
 480     virtual wxString GetType() const; \
 481     virtual wxClassInfo* GetValueClassInfo(); \
 482 \
 483     virtual wxVariantData* Clone() const { return new classname##VariantData(m_value); } \
 484 \
 485     DECLARE_WXANY_CONVERSION() \
 486 protected:\
 487     classname m_value; \
 488 };\
 489 \
 490 wxString classname##VariantData::GetType() const\
 491 {\
 492     return m_value.GetClassInfo()->GetClassName();\
 493 }\
 494 \
 495 wxClassInfo* classname##VariantData::GetValueClassInfo()\
 496 {\
 497     return m_value.GetClassInfo();\
 498 }\
 499 \
 500 expdecl classname& operator << ( classname &value, const wxVariant &variant )\
 501 {\
 502     wxASSERT( variant.GetType() == #classname );\
 503     \
 504     classname##VariantData *data = (classname##VariantData*) variant.GetData();\
 505     value = data->GetValue();\
 506     return value;\
 507 }\
 508 \
 509 expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
 510 {\
 511     classname##VariantData *data = new classname##VariantData( value );\
 512     variant.SetData( data );\
 513     return variant;\
 514 } \
 515 IMPLEMENT_TRIVIAL_WXANY_CONVERSION(classname, classname##VariantData)
 516
 517 // implements a wxVariantData-derived class using for the Eq() method the
 518 // operator== which must have been provided by "classname"
 519 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
 520 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
 521 \
 522 bool classname##VariantData::Eq(wxVariantData& data) const \
 523 {\
 524     wxASSERT( GetType() == data.GetType() );\
 525 \
 526     classname##VariantData & otherData = (classname##VariantData &) data;\
 527 \
 528     return otherData.m_value == m_value;\
 529 }\
 530
 531
 532 // implements a wxVariantData-derived class using for the Eq() method a shallow
 533 // comparison (through wxObject::IsSameAs function)
 534 #define IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(classname) \
 535     IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname, wxEMPTY_PARAMETER_VALUE)
 536 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname,expdecl) \
 537 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
 538 \
 539 bool classname##VariantData::Eq(wxVariantData& data) const \
 540 {\
 541     wxASSERT( GetType() == data.GetType() );\
 542 \
 543     classname##VariantData & otherData = (classname##VariantData &) data;\
 544 \
 545     return (otherData.m_value.IsSameAs(m_value));\
 546 }\
 547
 548
 549 // Since we want type safety wxVariant we need to fetch and dynamic_cast
 550 // in a seemingly safe way so the compiler can check, so we define
 551 // a dynamic_cast /wxDynamicCast analogue.
 552
 553 #define wxGetVariantCast(var,classname) \
 554     ((classname*)(var.IsValueKindOf(&classname::ms_classInfo) ?\
 555                   var.GetWxObjectPtr() : NULL));
 556
 557 // Replacement for using wxDynamicCast on a wxVariantData object
 558 #define wxDynamicCastVariantData(data, classname) dynamic_cast<classname*>(data)
 559
 560 extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;
 561
 562 #endif // wxUSE_VARIANT
 563
 564 #endif // _WX_VARIANT_H_