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     // wxUniChar
 234     wxVariant(const wxUniChar& val, const wxString& name = wxEmptyString);
 235     wxVariant(const wxUniCharRef& val, const wxString& name = wxEmptyString);
 236     wxVariant(char val, const wxString& name = wxEmptyString);
 237     wxVariant(wchar_t val, const wxString& name = wxEmptyString);
 238     bool operator==(const wxUniChar& value) const;
 239     bool operator==(const wxUniCharRef& value) const { return *this == wxUniChar(value); }
 240     bool operator==(char value) const { return *this == wxUniChar(value); }
 241     bool operator==(wchar_t value) const { return *this == wxUniChar(value); }
 242     bool operator!=(const wxUniChar& value) const { return !(*this == value); }
 243     bool operator!=(const wxUniCharRef& value) const { return !(*this == value); }
 244     bool operator!=(char value) const { return !(*this == value); }
 245     bool operator!=(wchar_t value) const { return !(*this == value); }
 246     wxVariant& operator=(const wxUniChar& value);
 247     wxVariant& operator=(const wxUniCharRef& value) { return *this = wxUniChar(value); }
 248     wxVariant& operator=(char value) { return *this = wxUniChar(value); }
 249     wxVariant& operator=(wchar_t value) { return *this = wxUniChar(value); }
 250     operator wxUniChar() const { return GetChar(); }
 251     operator char() const { return GetChar(); }
 252     operator wchar_t() const { return GetChar(); }
 253     wxUniChar GetChar() const;
 254
 255     // wxArrayString
 256     wxVariant(const wxArrayString& val, const wxString& name = wxEmptyString);
 257     bool operator== (const wxArrayString& value) const;
 258     bool operator!= (const wxArrayString& value) const;
 259     void operator= (const wxArrayString& value);
 260     operator wxArrayString () const { return GetArrayString(); }
 261     wxArrayString GetArrayString() const;
 262
 263     // void*
 264     wxVariant(void* ptr, const wxString& name = wxEmptyString);
 265     bool operator== (void* value) const;
 266     bool operator!= (void* value) const;
 267     void operator= (void* value);
 268     operator void* () const {  return GetVoidPtr(); }
 269     void* GetVoidPtr() const;
 270
 271     // wxObject*
 272     wxVariant(wxObject* ptr, const wxString& name = wxEmptyString);
 273     bool operator== (wxObject* value) const;
 274     bool operator!= (wxObject* value) const;
 275     void operator= (wxObject* value);
 276     wxObject* GetWxObjectPtr() const;
 277
 278 #if wxUSE_LONGLONG
 279     // wxLongLong
 280     wxVariant(wxLongLong, const wxString& name = wxEmptyString);
 281     bool operator==(wxLongLong value) const;
 282     bool operator!=(wxLongLong value) const;
 283     void operator=(wxLongLong value);
 284     operator wxLongLong() const { return GetLongLong(); }
 285     wxLongLong GetLongLong() const;
 286
 287     // wxULongLong
 288     wxVariant(wxULongLong, const wxString& name = wxEmptyString);
 289     bool operator==(wxULongLong value) const;
 290     bool operator!=(wxULongLong value) const;
 291     void operator=(wxULongLong value);
 292     operator wxULongLong() const { return GetULongLong(); }
 293     wxULongLong GetULongLong() const;
 294 #endif
 295
 296     // ------------------------------
 297     // list operations
 298     // ------------------------------
 299
 300     wxVariant(const wxVariantList& val, const wxString& name = wxEmptyString); // List of variants
 301     bool operator== (const wxVariantList& value) const;
 302     bool operator!= (const wxVariantList& value) const;
 303     void operator= (const wxVariantList& value) ;
 304     // Treat a list variant as an array
 305     wxVariant operator[] (size_t idx) const;
 306     wxVariant& operator[] (size_t idx) ;
 307     wxVariantList& GetList() const ;
 308
 309     // Return the number of elements in a list
 310     size_t GetCount() const;
 311
 312     // Make empty list
 313     void NullList();
 314
 315     // Append to list
 316     void Append(const wxVariant& value);
 317
 318     // Insert at front of list
 319     void Insert(const wxVariant& value);
 320
 321     // Returns true if the variant is a member of the list
 322     bool Member(const wxVariant& value) const;
 323
 324     // Deletes the nth element of the list
 325     bool Delete(size_t item);
 326
 327     // Clear list
 328     void ClearList();
 329
 330 public:
 331     // Type conversion
 332     bool Convert(long* value) const;
 333     bool Convert(bool* value) const;
 334     bool Convert(double* value) const;
 335     bool Convert(wxString* value) const;
 336     bool Convert(wxUniChar* value) const;
 337     bool Convert(char* value) const;
 338     bool Convert(wchar_t* value) const;
 339 #if wxUSE_DATETIME
 340     bool Convert(wxDateTime* value) const;
 341 #endif // wxUSE_DATETIME
 342 #if wxUSE_LONGLONG
 343     bool Convert(wxLongLong* value) const;
 344     bool Convert(wxULongLong* value) const;
 345 #endif // wxUSE_LONGLONG
 346
 347 // Attributes
 348 protected:
 349     virtual wxObjectRefData *CreateRefData() const;
 350     virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
 351
 352     wxString        m_name;
 353
 354 private:
 355     DECLARE_DYNAMIC_CLASS(wxVariant)
 356 };
 357
 358
 359 //
 360 // wxVariant <-> wxAny conversion code
 361 //
 362 #if wxUSE_ANY
 363
 364 #include "wx/any.h"
 365
 366 // In order to convert wxAny to wxVariant, we need to be able to associate
 367 // wxAnyValueType with a wxVariantData factory function.
 368 typedef wxVariantData* (*wxVariantDataFactory)(const wxAny& any);
 369
 370 // Actual Any-to-Variant registration must be postponed to a time when all
 371 // global variables have been initialized. Hence this arrangement.
 372 // wxAnyToVariantRegistration instances are kept in global scope and
 373 // wxAnyValueTypeGlobals in any.cpp will use their data when the time is
 374 // right.
 375 class WXDLLIMPEXP_BASE wxAnyToVariantRegistration
 376 {
 377 public:
 378     wxAnyToVariantRegistration(wxVariantDataFactory factory);
 379
 380     virtual wxAnyValueType* GetAssociatedType() = 0;
 381     wxVariantDataFactory GetFactory() const { return m_factory; }
 382 private:
 383     wxVariantDataFactory    m_factory;
 384 };
 385
 386 template<typename T>
 387 class wxAnyToVariantRegistrationImpl : public wxAnyToVariantRegistration
 388 {
 389 public:
 390     wxAnyToVariantRegistrationImpl(wxVariantDataFactory factory)
 391         : wxAnyToVariantRegistration(factory)
 392     {
 393     }
 394
 395     virtual wxAnyValueType* GetAssociatedType()
 396     {
 397         return wxAnyValueTypeImpl<T>::GetInstance();
 398     }
 399 private:
 400 };
 401
 402 #define DECLARE_WXANY_CONVERSION() \
 403 virtual bool GetAsAny(wxAny* any) const; \
 404 static wxVariantData* VariantDataFactory(const wxAny& any);
 405
 406 #define REGISTER_WXANY_CONVERSION(T, CLASSNAME) \
 407 static wxAnyToVariantRegistrationImpl<T> \
 408     gs_##CLASSNAME##AnyToVariantRegistration = \
 409     wxAnyToVariantRegistrationImpl<T>(&CLASSNAME::VariantDataFactory);
 410
 411 #define IMPLEMENT_TRIVIAL_WXANY_CONVERSION(T, CLASSNAME) \
 412 bool CLASSNAME::GetAsAny(wxAny* any) const \
 413 { \
 414     *any = m_value; \
 415     return true; \
 416 } \
 417 wxVariantData* CLASSNAME::VariantDataFactory(const wxAny& any) \
 418 { \
 419     return new CLASSNAME(wxANY_AS(any, T)); \
 420 } \
 421 REGISTER_WXANY_CONVERSION(T, CLASSNAME)
 422
 423 // This is needed for wxVariantList conversion
 424 WX_DECLARE_LIST_WITH_DECL(wxAny, wxAnyList, class WXDLLIMPEXP_BASE);
 425
 426 #else // if !wxUSE_ANY
 427
 428 #define DECLARE_WXANY_CONVERSION()
 429 #define REGISTER_WXANY_CONVERSION(T, CLASSNAME)
 430 #define IMPLEMENT_TRIVIAL_WXANY_CONVERSION(T, CLASSNAME)
 431
 432 #endif // wxUSE_ANY/!wxUSE_ANY
 433
 434
 435 #define DECLARE_VARIANT_OBJECT(classname) \
 436     DECLARE_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
 437
 438 #define DECLARE_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
 439 expdecl classname& operator << ( classname &object, const wxVariant &variant ); \
 440 expdecl wxVariant& operator << ( wxVariant &variant, const classname &object );
 441
 442 #define IMPLEMENT_VARIANT_OBJECT(classname) \
 443     IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
 444
 445 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
 446 class classname##VariantData: public wxVariantData \
 447 { \
 448 public:\
 449     classname##VariantData() {} \
 450     classname##VariantData( const classname &value ) { m_value = value; } \
 451 \
 452     classname &GetValue() { return m_value; } \
 453 \
 454     virtual bool Eq(wxVariantData& data) const; \
 455 \
 456     virtual wxString GetType() const; \
 457     virtual wxClassInfo* GetValueClassInfo(); \
 458 \
 459     virtual wxVariantData* Clone() const { return new classname##VariantData(m_value); } \
 460 \
 461     DECLARE_WXANY_CONVERSION() \
 462 protected:\
 463     classname m_value; \
 464 };\
 465 \
 466 wxString classname##VariantData::GetType() const\
 467 {\
 468     return m_value.GetClassInfo()->GetClassName();\
 469 }\
 470 \
 471 wxClassInfo* classname##VariantData::GetValueClassInfo()\
 472 {\
 473     return m_value.GetClassInfo();\
 474 }\
 475 \
 476 expdecl classname& operator << ( classname &value, const wxVariant &variant )\
 477 {\
 478     wxASSERT( variant.GetType() == #classname );\
 479     \
 480     classname##VariantData *data = (classname##VariantData*) variant.GetData();\
 481     value = data->GetValue();\
 482     return value;\
 483 }\
 484 \
 485 expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
 486 {\
 487     classname##VariantData *data = new classname##VariantData( value );\
 488     variant.SetData( data );\
 489     return variant;\
 490 } \
 491 IMPLEMENT_TRIVIAL_WXANY_CONVERSION(classname, classname##VariantData)
 492
 493 // implements a wxVariantData-derived class using for the Eq() method the
 494 // operator== which must have been provided by "classname"
 495 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
 496 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
 497 \
 498 bool classname##VariantData::Eq(wxVariantData& data) const \
 499 {\
 500     wxASSERT( GetType() == data.GetType() );\
 501 \
 502     classname##VariantData & otherData = (classname##VariantData &) data;\
 503 \
 504     return otherData.m_value == m_value;\
 505 }\
 506
 507
 508 // implements a wxVariantData-derived class using for the Eq() method a shallow
 509 // comparison (through wxObject::IsSameAs function)
 510 #define IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(classname) \
 511     IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname, wxEMPTY_PARAMETER_VALUE)
 512 #define IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname,expdecl) \
 513 IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
 514 \
 515 bool classname##VariantData::Eq(wxVariantData& data) const \
 516 {\
 517     wxASSERT( GetType() == data.GetType() );\
 518 \
 519     classname##VariantData & otherData = (classname##VariantData &) data;\
 520 \
 521     return (otherData.m_value.IsSameAs(m_value));\
 522 }\
 523
 524
 525 // Since we want type safety wxVariant we need to fetch and dynamic_cast
 526 // in a seemingly safe way so the compiler can check, so we define
 527 // a dynamic_cast /wxDynamicCast analogue.
 528
 529 #define wxGetVariantCast(var,classname) \
 530     ((classname*)(var.IsValueKindOf(&classname::ms_classInfo) ?\
 531                   var.GetWxObjectPtr() : NULL));
 532
 533 // Replacement for using wxDynamicCast on a wxVariantData object
 534 #define wxDynamicCastVariantData(data, classname) dynamic_cast<classname*>(data)
 535
 536 extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;
 537
 538 #endif // wxUSE_VARIANT
 539
 540 #endif // _WX_VARIANT_H_