include/wx/any.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/any.h
   3 // Purpose:     wxAny class
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     07/05/2009
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_ANY_H_
  13 #define _WX_ANY_H_
  14
  15 #include "wx/defs.h"
  16
  17 #if wxUSE_ANY
  18
  19 #include "wx/string.h"
  20 #include "wx/meta/movable.h"
  21 #include "wx/meta/if.h"
  22 #include "wx/typeinfo.h"
  23
  24
  25 // Size of the wxAny value buffer.
  26 enum
  27 {
  28     WX_ANY_VALUE_BUFFER_SIZE = 16
  29 };
  30
  31 union wxAnyValueBuffer
  32 {
  33     union Alignment
  34     {
  35     #if wxHAS_INT64
  36         wxInt64 m_int64;
  37     #endif
  38         long double m_longDouble;
  39         void ( *m_funcPtr )(void);
  40         void ( wxAnyValueBuffer::*m_mFuncPtr )(void);
  41     } m_alignment;
  42
  43     void*   m_ptr;
  44     wxByte  m_buffer[WX_ANY_VALUE_BUFFER_SIZE];
  45 };
  46
  47 //
  48 // wxAnyValueType is base class for value type functionality for C++ data
  49 // types used with wxAny. Usually the default template (wxAnyValueTypeImpl<>)
  50 // will create a satisfactory wxAnyValueType implementation for a data type.
  51 //
  52 class WXDLLIMPEXP_BASE wxAnyValueType
  53 {
  54     WX_DECLARE_ABSTRACT_TYPEINFO(wxAnyValueType)
  55 public:
  56     /**
  57         Default constructor.
  58     */
  59     wxAnyValueType();
  60
  61     /**
  62         Destructor.
  63     */
  64     virtual ~wxAnyValueType()
  65     {
  66     }
  67
  68     /**
  69         This function is used for internal type matching.
  70     */
  71     virtual bool IsSameType(const wxAnyValueType* otherType) const = 0;
  72
  73     /**
  74         This function is called every time the data in wxAny
  75         buffer needs to be freed.
  76     */
  77     virtual void DeleteValue(wxAnyValueBuffer& buf) const = 0;
  78
  79     /**
  80         Implement this for buffer-to-buffer copy.
  81
  82         @param src
  83             This is the source data buffer.
  84
  85         @param dst
  86             This is the destination data buffer that is in either
  87             uninitialized or freed state.
  88     */
  89     virtual void CopyBuffer(const wxAnyValueBuffer& src,
  90                             wxAnyValueBuffer& dst) const = 0;
  91
  92     /**
  93         Convert value into buffer of different type. Return false if
  94         not possible.
  95     */
  96     virtual bool ConvertValue(const wxAnyValueBuffer& src,
  97                               wxAnyValueType* dstType,
  98                               wxAnyValueBuffer& dst) const = 0;
  99
 100     /**
 101         Use this template function for checking if wxAnyValueType represents
 102         a specific C++ data type.
 103
 104         @remarks This template function does not work on some older compilers
 105                 (such as Visual C++ 6.0). For full compiler ccompatibility
 106                 please use wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) macro
 107                 instead.
 108
 109         @see wxAny::CheckType()
 110     */
 111     // FIXME-VC6: remove this hack when VC6 is no longer supported
 112     template <typename T>
 113     bool CheckType(T* reserved = NULL);
 114 private:
 115 };
 116
 117 //
 118 // This method of checking the type is compatible with VC6
 119 #define wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) \
 120     wxAnyValueTypeImpl<T>::IsSameClass(valueTypePtr)
 121
 122
 123 /**
 124     Helper macro for defining user value types.
 125
 126     Even though C++ RTTI would be fully available to use, we'd have to to
 127     facilitate sub-type system which allows, for instance, wxAny with
 128     signed short '15' to be treated equal to wxAny with signed long long '15'.
 129     Having sm_instance is important here.
 130 */
 131 #define WX_DECLARE_ANY_VALUE_TYPE(CLS) \
 132     friend class wxAny; \
 133     WX_DECLARE_TYPEINFO_INLINE(CLS) \
 134 public: \
 135     static bool IsSameClass(const wxAnyValueType* otherType) \
 136     { \
 137         return wxTypeId(*sm_instance) == wxTypeId(*otherType); \
 138     } \
 139     virtual bool IsSameType(const wxAnyValueType* otherType) const \
 140     { \
 141         return IsSameClass(otherType); \
 142     } \
 143 private: \
 144     static CLS* sm_instance; \
 145 public: \
 146     static wxAnyValueType* GetInstance() \
 147     { \
 148         return sm_instance; \
 149     }
 150
 151
 152 #define WX_IMPLEMENT_ANY_VALUE_TYPE(CLS) \
 153     CLS* CLS::sm_instance = new CLS();
 154
 155
 156 #ifdef __VISUALC6__
 157     // "non dll-interface class 'xxx' used as base interface
 158     #pragma warning (push)
 159     #pragma warning (disable:4275)
 160 #endif
 161
 162 /**
 163     Following are helper classes for the wxAnyValueTypeImplBase.
 164 */
 165 namespace wxPrivate
 166 {
 167
 168 template<typename T>
 169 class wxAnyValueTypeOpsMovable
 170 {
 171 public:
 172     static void DeleteValue(wxAnyValueBuffer& buf)
 173     {
 174         wxUnusedVar(buf);
 175     }
 176
 177     static void SetValue(const T& value,
 178                          wxAnyValueBuffer& buf)
 179     {
 180         memcpy(buf.m_buffer, &value, sizeof(T));
 181     }
 182
 183     static const T& GetValue(const wxAnyValueBuffer& buf)
 184     {
 185         // Breaking this code into two lines should supress
 186         // GCC's 'type-punned pointer will break strict-aliasing rules'
 187         // warning.
 188         const T* value = reinterpret_cast<const T*>(&buf.m_buffer[0]);
 189         return *value;
 190     }
 191 };
 192
 193
 194 template<typename T>
 195 class wxAnyValueTypeOpsGeneric
 196 {
 197 public:
 198     template<typename T2>
 199     class DataHolder
 200     {
 201     public:
 202         DataHolder(const T2& value)
 203         {
 204             m_value = value;
 205         }
 206         virtual ~DataHolder() { }
 207
 208         T2   m_value;
 209     private:
 210         wxDECLARE_NO_COPY_CLASS(DataHolder);
 211     };
 212
 213     static void DeleteValue(wxAnyValueBuffer& buf)
 214     {
 215         DataHolder<T>* holder = static_cast<DataHolder<T>*>(buf.m_ptr);
 216         delete holder;
 217     }
 218
 219     static void SetValue(const T& value,
 220                          wxAnyValueBuffer& buf)
 221     {
 222         DataHolder<T>* holder = new DataHolder<T>(value);
 223         buf.m_ptr = holder;
 224     }
 225
 226     static const T& GetValue(const wxAnyValueBuffer& buf)
 227     {
 228         DataHolder<T>* holder = static_cast<DataHolder<T>*>(buf.m_ptr);
 229         return holder->m_value;
 230     }
 231 };
 232
 233 } // namespace wxPrivate
 234
 235
 236 /**
 237     Intermediate template for the generic value type implementation.
 238     We can derive from this same value type for multiple actual types
 239     (for instance, we can have wxAnyValueTypeImplInt for all signed
 240     integer types), and also easily implement specialized templates
 241     with specific dynamic type conversion.
 242 */
 243 template<typename T>
 244 class wxAnyValueTypeImplBase : public wxAnyValueType
 245 {
 246     typedef typename wxIf< wxIsMovable<T>::value &&
 247                                 sizeof(T) <= WX_ANY_VALUE_BUFFER_SIZE,
 248                            wxPrivate::wxAnyValueTypeOpsMovable<T>,
 249                            wxPrivate::wxAnyValueTypeOpsGeneric<T> >::value
 250             Ops;
 251
 252 public:
 253     wxAnyValueTypeImplBase() : wxAnyValueType() { }
 254     virtual ~wxAnyValueTypeImplBase() { }
 255
 256     virtual void DeleteValue(wxAnyValueBuffer& buf) const
 257     {
 258         Ops::DeleteValue(buf);
 259     }
 260
 261     virtual void CopyBuffer(const wxAnyValueBuffer& src,
 262                             wxAnyValueBuffer& dst) const
 263     {
 264         Ops::SetValue(Ops::GetValue(src), dst);
 265     }
 266
 267     /**
 268         It is important to reimplement this in any specialized template
 269         classes that inherit from wxAnyValueTypeImplBase.
 270     */
 271     static void SetValue(const T& value,
 272                          wxAnyValueBuffer& buf)
 273     {
 274         Ops::SetValue(value, buf);
 275     }
 276
 277     /**
 278         It is important to reimplement this in any specialized template
 279         classes that inherit from wxAnyValueTypeImplBase.
 280     */
 281     static const T& GetValue(const wxAnyValueBuffer& buf)
 282     {
 283         return Ops::GetValue(buf);
 284     }
 285 };
 286
 287
 288 /*
 289     Generic value type template. Note that bulk of the implementation
 290     resides in wxAnyValueTypeImplBase.
 291 */
 292 template<typename T>
 293 class wxAnyValueTypeImpl : public wxAnyValueTypeImplBase<T>
 294 {
 295     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<T>)
 296 public:
 297     wxAnyValueTypeImpl() : wxAnyValueTypeImplBase<T>() { }
 298     virtual ~wxAnyValueTypeImpl() { }
 299
 300     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 301                               wxAnyValueType* dstType,
 302                               wxAnyValueBuffer& dst) const
 303     {
 304         wxUnusedVar(src);
 305         wxUnusedVar(dstType);
 306         wxUnusedVar(dst);
 307         return false;
 308     }
 309 };
 310
 311 template<typename T>
 312 wxAnyValueTypeImpl<T>* wxAnyValueTypeImpl<T>::sm_instance =
 313     new wxAnyValueTypeImpl<T>();
 314
 315
 316 //
 317 // Helper macro for using same base value type implementation for multiple
 318 // actual C++ data types.
 319 //
 320 #define WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE) \
 321 template<> \
 322 class wxAnyValueTypeImpl<T> : public wxAnyValueTypeImpl##CLSTYPE \
 323 { \
 324     typedef wxAnyBase##CLSTYPE##Type UseDataType; \
 325 public: \
 326     wxAnyValueTypeImpl() : wxAnyValueTypeImpl##CLSTYPE() { } \
 327     virtual ~wxAnyValueTypeImpl() { } \
 328     static void SetValue(const T& value, wxAnyValueBuffer& buf) \
 329     { \
 330         void* voidPtr = reinterpret_cast<void*>(&buf.m_buffer[0]); \
 331         UseDataType* dptr = reinterpret_cast<UseDataType*>(voidPtr); \
 332         *dptr = static_cast<UseDataType>(value); \
 333     } \
 334     static T GetValue(const wxAnyValueBuffer& buf) \
 335     { \
 336         const void* voidPtr = \
 337             reinterpret_cast<const void*>(&buf.m_buffer[0]); \
 338         const UseDataType* sptr = \
 339             reinterpret_cast<const UseDataType*>(voidPtr); \
 340         return static_cast<T>(*sptr); \
 341     } \
 342 };
 343
 344
 345 //
 346 //  Integer value types
 347 //
 348
 349 #ifdef wxLongLong_t
 350     typedef wxLongLong_t wxAnyBaseIntType;
 351     typedef wxULongLong_t wxAnyBaseUintType;
 352 #else
 353     typedef long wxAnyBaseIntType;
 354     typedef unsigned long wxAnyBaseUintType;
 355 #endif
 356
 357
 358 class WXDLLIMPEXP_BASE wxAnyValueTypeImplInt :
 359     public wxAnyValueTypeImplBase<wxAnyBaseIntType>
 360 {
 361     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplInt)
 362 public:
 363     wxAnyValueTypeImplInt() :
 364         wxAnyValueTypeImplBase<wxAnyBaseIntType>() { }
 365     virtual ~wxAnyValueTypeImplInt() { }
 366
 367     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 368                               wxAnyValueType* dstType,
 369                               wxAnyValueBuffer& dst) const;
 370 };
 371
 372
 373 class WXDLLIMPEXP_BASE wxAnyValueTypeImplUint :
 374     public wxAnyValueTypeImplBase<wxAnyBaseUintType>
 375 {
 376     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplUint)
 377 public:
 378     wxAnyValueTypeImplUint() :
 379         wxAnyValueTypeImplBase<wxAnyBaseUintType>() { }
 380     virtual ~wxAnyValueTypeImplUint() { }
 381
 382     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 383                               wxAnyValueType* dstType,
 384                               wxAnyValueBuffer& dst) const;
 385 };
 386
 387
 388 WX_ANY_DEFINE_SUB_TYPE(signed long, Int)
 389 WX_ANY_DEFINE_SUB_TYPE(signed int, Int)
 390 WX_ANY_DEFINE_SUB_TYPE(signed short, Int)
 391 WX_ANY_DEFINE_SUB_TYPE(signed char, Int)
 392 #ifdef wxLongLong_t
 393 WX_ANY_DEFINE_SUB_TYPE(wxLongLong_t, Int)
 394 #endif
 395
 396 WX_ANY_DEFINE_SUB_TYPE(unsigned long, Uint)
 397 WX_ANY_DEFINE_SUB_TYPE(unsigned int, Uint)
 398 WX_ANY_DEFINE_SUB_TYPE(unsigned short, Uint)
 399 WX_ANY_DEFINE_SUB_TYPE(unsigned char, Uint)
 400 #ifdef wxLongLong_t
 401 WX_ANY_DEFINE_SUB_TYPE(wxULongLong_t, Uint)
 402 #endif
 403
 404
 405 //
 406 // String value type
 407 //
 408 class WXDLLIMPEXP_BASE wxAnyValueTypeImplString :
 409     public wxAnyValueTypeImplBase<wxString>
 410 {
 411     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplString)
 412 public:
 413     wxAnyValueTypeImplString() :
 414         wxAnyValueTypeImplBase<wxString>() { }
 415     virtual ~wxAnyValueTypeImplString() { }
 416
 417     /**
 418         Convert value into buffer of different type. Return false if
 419         not possible.
 420     */
 421     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 422                               wxAnyValueType* dstType,
 423                               wxAnyValueBuffer& dst) const;
 424
 425 };
 426
 427 template<>
 428 class wxAnyValueTypeImpl<wxString> : public wxAnyValueTypeImplString
 429 {
 430 public:
 431     wxAnyValueTypeImpl() : wxAnyValueTypeImplString() { }
 432     virtual ~wxAnyValueTypeImpl() { }
 433 };
 434
 435
 436 //
 437 // Bool value type
 438 //
 439 template<>
 440 class WXDLLIMPEXP_BASE wxAnyValueTypeImpl<bool> :
 441     public wxAnyValueTypeImplBase<bool>
 442 {
 443     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<bool>)
 444 public:
 445     wxAnyValueTypeImpl() :
 446         wxAnyValueTypeImplBase<bool>() { }
 447     virtual ~wxAnyValueTypeImpl() { }
 448
 449     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 450                               wxAnyValueType* dstType,
 451                               wxAnyValueBuffer& dst) const;
 452 };
 453
 454 //
 455 // Floating point value type
 456 //
 457 class WXDLLIMPEXP_BASE wxAnyValueTypeImplDouble :
 458     public wxAnyValueTypeImplBase<double>
 459 {
 460     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplDouble)
 461 public:
 462     wxAnyValueTypeImplDouble() :
 463         wxAnyValueTypeImplBase<double>() { }
 464     virtual ~wxAnyValueTypeImplDouble() { }
 465
 466     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 467                               wxAnyValueType* dstType,
 468                               wxAnyValueBuffer& dst) const;
 469 };
 470
 471 // WX_ANY_DEFINE_SUB_TYPE requires this
 472 typedef double wxAnyBaseDoubleType;
 473
 474 WX_ANY_DEFINE_SUB_TYPE(float, Double)
 475 WX_ANY_DEFINE_SUB_TYPE(double, Double)
 476
 477
 478 //
 479 // Defines a dummy wxAnyValueTypeImpl<> with given export
 480 // declaration. This is needed if a class is used with
 481 // wxAny in both user shared library and application.
 482 //
 483 #define wxDECLARE_ANY_TYPE(CLS, DECL) \
 484 template<> \
 485 class DECL wxAnyValueTypeImpl<CLS> : \
 486     public wxAnyValueTypeImplBase<CLS> \
 487 { \
 488     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<CLS>) \
 489 public: \
 490     wxAnyValueTypeImpl() : \
 491         wxAnyValueTypeImplBase<CLS>() { } \
 492     virtual ~wxAnyValueTypeImpl() { } \
 493  \
 494     virtual bool ConvertValue(const wxAnyValueBuffer& src, \
 495                               wxAnyValueType* dstType, \
 496                               wxAnyValueBuffer& dst) const \
 497     { \
 498         wxUnusedVar(src); \
 499         wxUnusedVar(dstType); \
 500         wxUnusedVar(dst); \
 501         return false; \
 502     } \
 503 };
 504
 505
 506 // Make sure some of wx's own types get the right wxAnyValueType export
 507 // (this is needed only for types that are referred to from wxBase.
 508 // currently we may not use any of these types from there, but let's
 509 // use the macro on at least one to make sure it compiles since we can't
 510 // really test it properly in unittests since a separate DLL would
 511 // be needed).
 512 #if wxUSE_DATETIME
 513     #include "wx/datetime.h"
 514     wxDECLARE_ANY_TYPE(wxDateTime, WXDLLIMPEXP_BASE)
 515 #endif
 516
 517 //#include "wx/object.h"
 518 //wxDECLARE_ANY_TYPE(wxObject*, WXDLLIMPEXP_BASE)
 519
 520 //#include "wx/arrstr.h"
 521 //wxDECLARE_ANY_TYPE(wxArrayString, WXDLLIMPEXP_BASE)
 522
 523
 524 #if wxUSE_VARIANT
 525
 526 class WXDLLIMPEXP_FWD_BASE wxAnyToVariantRegistration;
 527
 528 // Because of header inter-dependencies, cannot include this earlier
 529 #include "wx/variant.h"
 530
 531 //
 532 // wxVariantData* data type implementation. For cases when appropriate
 533 // wxAny<->wxVariant conversion code is missing.
 534 //
 535
 536 class WXDLLIMPEXP_BASE wxAnyValueTypeImplVariantData :
 537     public wxAnyValueTypeImplBase<wxVariantData*>
 538 {
 539     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplVariantData)
 540 public:
 541     wxAnyValueTypeImplVariantData() :
 542         wxAnyValueTypeImplBase<wxVariantData*>() { }
 543     virtual ~wxAnyValueTypeImplVariantData() { }
 544
 545     virtual void DeleteValue(wxAnyValueBuffer& buf) const
 546     {
 547         wxVariantData* data = static_cast<wxVariantData*>(buf.m_ptr);
 548         if ( data )
 549             data->DecRef();
 550     }
 551
 552     virtual void CopyBuffer(const wxAnyValueBuffer& src,
 553                             wxAnyValueBuffer& dst) const
 554     {
 555         wxVariantData* data = static_cast<wxVariantData*>(src.m_ptr);
 556         if ( data )
 557             data->IncRef();
 558         dst.m_ptr = data;
 559     }
 560
 561     static void SetValue(wxVariantData* value,
 562                          wxAnyValueBuffer& buf)
 563     {
 564         value->IncRef();
 565         buf.m_ptr = value;
 566     }
 567
 568     static wxVariantData* GetValue(const wxAnyValueBuffer& buf)
 569     {
 570         return static_cast<wxVariantData*>(buf.m_ptr);
 571     }
 572
 573     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 574                               wxAnyValueType* dstType,
 575                               wxAnyValueBuffer& dst) const
 576     {
 577         wxUnusedVar(src);
 578         wxUnusedVar(dstType);
 579         wxUnusedVar(dst);
 580         return false;
 581     }
 582 };
 583
 584 template<>
 585 class wxAnyValueTypeImpl<wxVariantData*> :
 586     public wxAnyValueTypeImplVariantData
 587 {
 588 public:
 589     wxAnyValueTypeImpl() : wxAnyValueTypeImplVariantData() { }
 590     virtual ~wxAnyValueTypeImpl() { }
 591 };
 592
 593 #endif // wxUSE_VARIANT
 594
 595 #ifdef __VISUALC6__
 596     // Re-enable useless VC6 warnings
 597     #pragma warning (pop)
 598 #endif
 599
 600
 601 /*
 602     Let's define a discrete Null value so we don't have to really
 603     ever check if wxAny.m_type pointer is NULL or not. This is an
 604     optimization, mostly. Implementation of this value type is
 605     "hidden" in the source file.
 606 */
 607 extern WXDLLIMPEXP_DATA_BASE(wxAnyValueType*) wxAnyNullValueType;
 608
 609
 610 //
 611 // We need to implement custom signed/unsigned int equals operators
 612 // for signed/unsigned (eg. wxAny(128UL) == 128L) comparisons to work.
 613 #define WXANY_IMPLEMENT_INT_EQ_OP(TS, TUS) \
 614 bool operator==(TS value) const \
 615 { \
 616     if ( wxAnyValueTypeImpl<TS>::IsSameClass(m_type) ) \
 617         return (value == static_cast<TS> \
 618                 (wxAnyValueTypeImpl<TS>::GetValue(m_buffer))); \
 619     if ( wxAnyValueTypeImpl<TUS>::IsSameClass(m_type) ) \
 620         return (value == static_cast<TS> \
 621                 (wxAnyValueTypeImpl<TUS>::GetValue(m_buffer))); \
 622     return false; \
 623 } \
 624 bool operator==(TUS value) const \
 625 { \
 626     if ( wxAnyValueTypeImpl<TUS>::IsSameClass(m_type) ) \
 627         return (value == static_cast<TUS> \
 628                 (wxAnyValueTypeImpl<TUS>::GetValue(m_buffer))); \
 629     if ( wxAnyValueTypeImpl<TS>::IsSameClass(m_type) ) \
 630         return (value == static_cast<TUS> \
 631                 (wxAnyValueTypeImpl<TS>::GetValue(m_buffer))); \
 632     return false; \
 633 }
 634
 635
 636 #if wxUSE_VARIANT
 637
 638 // Note that the following functions are implemented outside wxAny class
 639 // so that it can reside entirely in header and lack the export declaration.
 640
 641 // Helper function used to associate wxAnyValueType with a wxVariantData.
 642 extern WXDLLIMPEXP_BASE void
 643 wxPreRegisterAnyToVariant(wxAnyToVariantRegistration* reg);
 644
 645 // This function performs main wxAny to wxVariant conversion duties.
 646 extern WXDLLIMPEXP_BASE bool
 647 wxConvertAnyToVariant(const wxAny& any, wxVariant* variant);
 648
 649 #endif // wxUSE_VARIANT
 650
 651
 652 //
 653 // The wxAny class represents a container for any type. A variant's value
 654 // can be changed at run time, possibly to a different type of value.
 655 //
 656 // As standard, wxAny can store value of almost any type, in a fairly
 657 // optimal manner even.
 658 //
 659 class wxAny
 660 {
 661 public:
 662     /**
 663         Default constructor.
 664     */
 665     wxAny()
 666     {
 667         m_type = wxAnyNullValueType;
 668     }
 669
 670     /**
 671         Destructor.
 672     */
 673     ~wxAny()
 674     {
 675         m_type->DeleteValue(m_buffer);
 676     }
 677
 678     //@{
 679     /**
 680         Various constructors.
 681     */
 682     template<typename T>
 683     wxAny(const T& value)
 684     {
 685         m_type = wxAnyValueTypeImpl<T>::sm_instance;
 686         wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
 687     }
 688
 689     wxAny(const char* value)
 690     {
 691         m_type = wxAnyNullValueType;
 692         Assign(wxString(value));
 693     }
 694
 695     wxAny(const wchar_t* value)
 696     {
 697         m_type = wxAnyNullValueType;
 698         Assign(wxString(value));
 699     }
 700
 701     wxAny(const wxAny& any)
 702     {
 703         m_type = wxAnyNullValueType;
 704         AssignAny(any);
 705     }
 706
 707 #if wxUSE_VARIANT
 708     wxAny(const wxVariant& variant)
 709     {
 710         m_type = wxAnyNullValueType;
 711         AssignVariant(variant);
 712     }
 713 #endif
 714
 715     //@}
 716
 717     /**
 718         Use this template function for checking if this wxAny holds
 719         a specific C++ data type.
 720
 721         @remarks This template function does not work on some older compilers
 722                 (such as Visual C++ 6.0). For full compiler ccompatibility
 723                 please use wxANY_CHECK_TYPE(any, T) macro instead.
 724
 725         @see wxAnyValueType::CheckType()
 726     */
 727     // FIXME-VC6: remove this hack when VC6 is no longer supported
 728     template <typename T>
 729     bool CheckType(T* = NULL)
 730     {
 731         return m_type->CheckType<T>();
 732     }
 733
 734     /**
 735         Returns the value type as wxAnyValueType instance.
 736
 737         @remarks You cannot reliably test whether two wxAnys are of
 738                  same value type by simply comparing return values
 739                  of wxAny::GetType(). Instead use
 740                  wxAnyValueType::CheckType<T>() template function.
 741     */
 742     const wxAnyValueType* GetType() const
 743     {
 744         return m_type;
 745     }
 746
 747     /**
 748         Tests if wxAny is null (that is, whether there is data).
 749     */
 750     bool IsNull() const
 751     {
 752         return (m_type == wxAnyNullValueType);
 753     }
 754
 755     /**
 756         Makes wxAny null (that is, clears it).
 757     */
 758     void MakeNull()
 759     {
 760         m_type->DeleteValue(m_buffer);
 761         m_type = wxAnyNullValueType;
 762     }
 763
 764     //@{
 765     /**
 766         Assignment operators.
 767     */
 768     wxAny& operator=(const wxAny &any)
 769     {
 770         if (this != &any)
 771             AssignAny(any);
 772         return *this;
 773     }
 774
 775 #if wxUSE_VARIANT && (!defined(__VISUALC__) || __VISUALC__ >= 1300)
 776     //
 777     // Adding this operator for VC6 breaks wxAny, and also
 778     // some cases of implicit conversion from wxVariant to wxAny.
 779     //
 780     // e.g. wxAny any = variant;  // should work
 781     //
 782     //      wxAny any;
 783     //      any = 16;
 784     //      any = variant;  // probably doesn't work - uses template
 785     //                      // assignment, most likely
 786     //
 787     wxAny& operator=(const wxVariant &variant)
 788     {
 789         AssignVariant(variant);
 790         return *this;
 791     }
 792 #endif
 793
 794     template<typename T>
 795     wxAny& operator=(const T &value)
 796     {
 797         m_type->DeleteValue(m_buffer);
 798         m_type = wxAnyValueTypeImpl<T>::sm_instance;
 799         wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
 800         return *this;
 801     }
 802
 803     wxAny& operator=(const char* value)
 804         { Assign(wxString(value)); return *this; }
 805     wxAny& operator=(const wchar_t* value)
 806         { Assign(wxString(value)); return *this; }
 807     //@}
 808
 809     //@{
 810     /**
 811         Equality operators.
 812     */
 813     bool operator==(const wxString& value) const
 814     {
 815         if ( !wxAnyValueTypeImpl<wxString>::IsSameClass(m_type) )
 816             return false;
 817
 818         return value ==
 819             static_cast<wxString>
 820                 (wxAnyValueTypeImpl<wxString>::GetValue(m_buffer));
 821     }
 822
 823     bool operator==(const char* value) const
 824         { return (*this) == wxString(value); }
 825     bool operator==(const wchar_t* value) const
 826         { return (*this) == wxString(value); }
 827
 828     //
 829     // We need to implement custom signed/unsigned int equals operators
 830     // for signed/unsigned (eg. wxAny(128UL) == 128L) comparisons to work.
 831     WXANY_IMPLEMENT_INT_EQ_OP(signed char, unsigned char)
 832     WXANY_IMPLEMENT_INT_EQ_OP(signed short, unsigned short)
 833     WXANY_IMPLEMENT_INT_EQ_OP(signed int, unsigned int)
 834     WXANY_IMPLEMENT_INT_EQ_OP(signed long, unsigned long)
 835 #ifdef wxLongLong_t
 836     WXANY_IMPLEMENT_INT_EQ_OP(wxLongLong_t, wxULongLong_t)
 837 #endif
 838
 839     bool operator==(float value) const
 840     {
 841         if ( !wxAnyValueTypeImpl<float>::IsSameClass(m_type) )
 842             return false;
 843
 844         return value ==
 845             static_cast<float>
 846                 (wxAnyValueTypeImpl<float>::GetValue(m_buffer));
 847     }
 848
 849     bool operator==(double value) const
 850     {
 851         if ( !wxAnyValueTypeImpl<double>::IsSameClass(m_type) )
 852             return false;
 853
 854         return value ==
 855             static_cast<double>
 856                 (wxAnyValueTypeImpl<double>::GetValue(m_buffer));
 857     }
 858
 859     bool operator==(bool value) const
 860     {
 861         if ( !wxAnyValueTypeImpl<bool>::IsSameClass(m_type) )
 862             return false;
 863
 864         return value == (wxAnyValueTypeImpl<bool>::GetValue(m_buffer));
 865     }
 866
 867     //@}
 868
 869     //@{
 870     /**
 871         Inequality operators (implement as template).
 872     */
 873     template<typename T>
 874     bool operator!=(const T& value) const
 875         { return !((*this) == value); }
 876     //@}
 877
 878     /**
 879         This template function converts wxAny into given type. No dynamic
 880         conversion is performed, so if the type is incorrect an assertion
 881         failure will occur in debug builds, and a bogus value is returned
 882         in release ones.
 883
 884         @remarks This template function does not work on some older compilers
 885                 (such as Visual C++ 6.0). For full compiler compatibility
 886                 please use wxANY_AS(any, T) macro instead.
 887     */
 888     // FIXME-VC6: remove this hack when VC6 is no longer supported
 889     template<typename T>
 890     T As(T* = NULL) const
 891     {
 892         if ( !wxAnyValueTypeImpl<T>::IsSameClass(m_type) )
 893         {
 894             wxFAIL_MSG("Incorrect or non-convertible data type");
 895         }
 896
 897         return static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(m_buffer));
 898     }
 899
 900     /**
 901         Template function that etrieves and converts the value of this
 902         variant to the type that T* value is.
 903
 904         @return Returns @true if conversion was succesfull.
 905     */
 906     template<typename T>
 907     bool GetAs(T* value) const
 908     {
 909         if ( !wxAnyValueTypeImpl<T>::IsSameClass(m_type) )
 910         {
 911             wxAnyValueType* otherType =
 912                 wxAnyValueTypeImpl<T>::sm_instance;
 913             wxAnyValueBuffer temp_buf;
 914
 915             if ( !m_type->ConvertValue(m_buffer, otherType, temp_buf) )
 916                 return false;
 917
 918             *value =
 919                 static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(temp_buf));
 920             otherType->DeleteValue(temp_buf);
 921
 922             return true;
 923         }
 924         *value = static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(m_buffer));
 925         return true;
 926     }
 927
 928 #if wxUSE_VARIANT
 929     // GetAs() wxVariant specialization
 930     bool GetAs(wxVariant* value) const
 931     {
 932         return wxConvertAnyToVariant(*this, value);
 933     }
 934 #endif
 935
 936 private:
 937     // Assignment functions
 938     void AssignAny(const wxAny& any)
 939     {
 940         // Must delete value - CopyBuffer() never does that
 941         m_type->DeleteValue(m_buffer);
 942
 943         wxAnyValueType* newType = any.m_type;
 944
 945         if ( !newType->IsSameType(m_type) )
 946             m_type = newType;
 947
 948         newType->CopyBuffer(any.m_buffer, m_buffer);
 949     }
 950
 951 #if wxUSE_VARIANT
 952     void AssignVariant(const wxVariant& variant)
 953     {
 954         wxVariantData* data = variant.GetData();
 955
 956         if ( data && data->GetAsAny(this) )
 957             return;
 958
 959         m_type->DeleteValue(m_buffer);
 960
 961         if ( variant.IsNull() )
 962         {
 963             // Init as Null
 964             m_type = wxAnyNullValueType;
 965         }
 966         else
 967         {
 968             // If everything else fails, wrap the whole wxVariantData
 969             m_type = wxAnyValueTypeImpl<wxVariantData*>::sm_instance;
 970             wxAnyValueTypeImpl<wxVariantData*>::SetValue(data, m_buffer);
 971         }
 972     }
 973 #endif
 974
 975     template<typename T>
 976     void Assign(const T &value)
 977     {
 978         m_type->DeleteValue(m_buffer);
 979         m_type = wxAnyValueTypeImpl<T>::sm_instance;
 980         wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
 981     }
 982
 983     // Data
 984     wxAnyValueBuffer    m_buffer;
 985     wxAnyValueType*     m_type;
 986 };
 987
 988
 989 //
 990 // This method of checking the type is compatible with VC6
 991 #define wxANY_CHECK_TYPE(any, T) \
 992     wxANY_VALUE_TYPE_CHECK_TYPE(any.GetType(), T)
 993
 994
 995 //
 996 // This method of getting the value is compatible with VC6
 997 #define wxANY_AS(any, T) \
 998     any.As(static_cast<T*>(NULL))
 999
1000
1001 template<typename T>
1002 inline bool wxAnyValueType::CheckType(T* reserved)
1003 {
1004     wxUnusedVar(reserved);
1005     return wxAnyValueTypeImpl<T>::IsSameClass(this);
1006 }
1007
1008
1009
1010 #endif // wxUSE_ANY
1011
1012 #endif // _WX_ANY_H_