src/common/any.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/any.cpp
   3 // Purpose:     wxAny class, container for any type
   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 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #include "wx/any.h"
  20
  21 #if wxUSE_ANY
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/math.h"
  25     #include "wx/crt.h"
  26 #endif
  27
  28 #include "wx/vector.h"
  29 #include "wx/module.h"
  30 #include "wx/hashmap.h"
  31 #include "wx/hashset.h"
  32
  33 using namespace wxPrivate;
  34
  35 //-------------------------------------------------------------------------
  36 // wxAnyValueTypeGlobals
  37 //-------------------------------------------------------------------------
  38
  39 #if wxUSE_VARIANT
  40
  41 WX_DECLARE_HASH_MAP(wxAnyValueType*,
  42                     wxVariantDataFactory,
  43                     wxPointerHash,
  44                     wxPointerEqual,
  45                     wxAnyTypeToVariantDataFactoryMap);
  46
  47 #endif
  48
  49 WX_DECLARE_HASH_SET(wxAnyValueType*,
  50                     wxPointerHash,
  51                     wxPointerEqual,
  52                     wxAnyValueTypePtrSet);
  53
  54 //
  55 // Helper class to manage wxAnyValueType instances and and other
  56 // related global variables (such as wxAny<->wxVariant type association).
  57 //
  58 // NB: We really need to have wxAnyValueType instances allocated
  59 //     in heap. They are stored as static template member variables,
  60 //     and with them we just can't be too careful (eg. not allocating
  61 //     them in heap broke the type identification in GCC).
  62 //
  63 class wxAnyValueTypeGlobals
  64 {
  65 public:
  66     wxAnyValueTypeGlobals()
  67     {
  68     }
  69     ~wxAnyValueTypeGlobals()
  70     {
  71     #if wxUSE_VARIANT
  72         m_anyToVariant.clear();
  73     #endif
  74
  75         wxAnyValueTypePtrSet::iterator it;
  76         for ( it = m_valueTypes.begin(); it != m_valueTypes.end(); ++it )
  77         {
  78             delete *it;
  79         }
  80     }
  81
  82     void RegisterValueType(wxAnyValueType* valueType)
  83     {
  84         // Let's store value types in set to prevent deleting the same object
  85         // several times (it may be possible, under certain conditions, that
  86         // the same wxAnyValueType instance gets registered twice)
  87         m_valueTypes.insert(valueType);
  88     }
  89
  90 #if wxUSE_VARIANT
  91     void PreRegisterAnyToVariant(wxAnyToVariantRegistration* reg)
  92     {
  93         m_anyToVariantRegs.push_back(reg);
  94     }
  95
  96     // Find wxVariantData factory function for given value type,
  97     // (or compatible, if possible)
  98     wxVariantDataFactory FindVariantDataFactory(const wxAnyValueType* type_)
  99     {
 100         // Ideally we'd have the hash map of type 'const wxAnyValueType*',
 101         // but WX_DECLARE_HASH_MAP() has some trouble with it.
 102         wxAnyValueType* type = const_cast<wxAnyValueType*>(type_);
 103
 104         wxAnyTypeToVariantDataFactoryMap& anyToVariant = m_anyToVariant;
 105         wxAnyTypeToVariantDataFactoryMap::const_iterator it;
 106         it = anyToVariant.find(type);
 107         if ( it != anyToVariant.end() )
 108             return it->second;
 109
 110         // Not found, handle pre-registrations
 111         size_t i = m_anyToVariantRegs.size();
 112         while ( i > 0 )
 113         {
 114             i--;
 115             wxAnyToVariantRegistration* reg = m_anyToVariantRegs[i];
 116             wxAnyValueType* assocType = reg->GetAssociatedType();
 117             if ( assocType )
 118             {
 119                 // Both variant data and wxAnyValueType have been
 120                 // now been properly initialized, so remove the
 121                 // pre-registration entry and move data to anyToVarian
 122                 // map.
 123                 anyToVariant[assocType] = reg->GetFactory();
 124                 m_anyToVariantRegs.erase( m_anyToVariantRegs.begin() + i );
 125             }
 126         }
 127
 128         // Then try again
 129         it = anyToVariant.find(type);
 130         if ( it != anyToVariant.end() )
 131             return it->second;
 132
 133         // Finally, attempt to find a compatible type
 134         for ( it = anyToVariant.begin(); it != anyToVariant.end(); it++ )
 135         {
 136             if ( type->IsSameType(it->first) )
 137             {
 138                 wxVariantDataFactory f = it->second;
 139                 anyToVariant[type] = f;
 140                 return f;
 141             }
 142         }
 143
 144         // Nothing found
 145         return NULL;
 146     }
 147 #endif
 148
 149 private:
 150     wxAnyValueTypePtrSet                    m_valueTypes;
 151 #if wxUSE_VARIANT
 152     wxAnyTypeToVariantDataFactoryMap        m_anyToVariant;
 153     wxVector<wxAnyToVariantRegistration*>   m_anyToVariantRegs;
 154 #endif
 155 };
 156
 157 static wxAnyValueTypeGlobals* g_wxAnyValueTypeGlobals = NULL;
 158
 159 #if wxUSE_VARIANT
 160
 161 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplVariantData)
 162
 163 void wxPreRegisterAnyToVariant(wxAnyToVariantRegistration* reg)
 164 {
 165     if ( !g_wxAnyValueTypeGlobals )
 166         g_wxAnyValueTypeGlobals = new wxAnyValueTypeGlobals();
 167     g_wxAnyValueTypeGlobals->PreRegisterAnyToVariant(reg);
 168 }
 169
 170 bool wxConvertAnyToVariant(const wxAny& any, wxVariant* variant)
 171 {
 172     if ( any.IsNull() )
 173     {
 174         variant->MakeNull();
 175         return true;
 176     }
 177
 178     // (signed) integer is a special case, because there is only one type
 179     // in wxAny, and two ("long" and "longlong") in wxVariant. For better
 180     // backwards compatibility, convert all values that fit in "long",
 181     // and others to "longlong".
 182     if ( wxANY_CHECK_TYPE(any, signed int) )
 183     {
 184 #ifdef wxLongLong_t
 185         wxLongLong_t ll = 0;
 186         if ( any.GetAs(&ll) )
 187         {
 188             // NB: Do not use LONG_MAX here. Explicitly using 32-bit
 189             //     integer constraint yields more consistent behavior across
 190             //     builds.
 191             if ( ll > wxINT32_MAX || ll < wxINT32_MIN )
 192                 *variant = wxLongLong(ll);
 193             else
 194                 *variant = (long) wxLongLong(ll).GetLo();
 195         }
 196         else
 197         {
 198             return false;
 199         }
 200 #else
 201         long l;
 202         if ( any.GetAs(&l) )
 203             *variant = l;
 204         else
 205             return false;
 206 #endif
 207         return true;
 208     }
 209
 210     // Find matching factory function
 211     wxVariantDataFactory f =
 212         g_wxAnyValueTypeGlobals->FindVariantDataFactory(any.GetType());
 213
 214     wxVariantData* data = NULL;
 215
 216     if ( f )
 217     {
 218         data = f(any);
 219     }
 220     else
 221     {
 222         // Check if wxAny wrapped wxVariantData*
 223         if ( !any.GetAs(&data) )
 224         {
 225             // Ok, one last chance: while unlikely, it is possible that the
 226             // wxAny actually contains wxVariant.
 227             if ( wxANY_CHECK_TYPE(any, wxVariant) )
 228                 *variant = wxANY_AS(any, wxVariant);
 229             return false;
 230         }
 231
 232         // Wrapper's GetValue() does not increase reference
 233         // count, se have to do it before the data gets passed
 234         // to a new variant.
 235         data->IncRef();
 236     }
 237
 238     variant->SetData(data);
 239     return true;
 240 }
 241
 242 #endif // wxUSE_VARIANT
 243
 244 //
 245 // This class is to make sure that wxAnyValueType instances
 246 // etc. get freed correctly. We must use a separate wxAnyValueTypeGlobals
 247 // because wxModule itself is instantiated too late.
 248 //
 249 class wxAnyValueTypeGlobalsManager : public wxModule
 250 {
 251     DECLARE_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager)
 252 public:
 253     wxAnyValueTypeGlobalsManager() : wxModule() { }
 254     virtual ~wxAnyValueTypeGlobalsManager() { }
 255
 256     virtual bool OnInit()
 257     {
 258         return true;
 259     }
 260     virtual void OnExit()
 261     {
 262         delete g_wxAnyValueTypeGlobals;
 263         g_wxAnyValueTypeGlobals = NULL;
 264     }
 265 private:
 266 };
 267
 268 IMPLEMENT_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager, wxModule)
 269
 270
 271 //-------------------------------------------------------------------------
 272 // wxAnyValueType
 273 //-------------------------------------------------------------------------
 274
 275 wxAnyValueType::wxAnyValueType()
 276 {
 277     if ( !g_wxAnyValueTypeGlobals )
 278         g_wxAnyValueTypeGlobals = new wxAnyValueTypeGlobals();
 279
 280     g_wxAnyValueTypeGlobals->RegisterValueType(this);
 281 }
 282
 283 //-------------------------------------------------------------------------
 284 // Dynamic conversion member functions
 285 //-------------------------------------------------------------------------
 286
 287 //
 288 // Define integer minimum and maximum as helpers
 289 #ifdef wxLongLong_t
 290     #define UseIntMin  (wxINT64_MIN)
 291     #define UseIntMax  (wxINT64_MAX)
 292     #define UseUintMax (wxUINT64_MAX)
 293 #else
 294     #define UseIntMin  (LONG_MIN)
 295     #define UseIntMax  (LONG_MAX)
 296     #define UseUintMax (ULONG_MAX)
 297 #endif
 298
 299 namespace
 300 {
 301
 302 const double UseIntMinF = static_cast<double>(UseIntMin);
 303 const double UseIntMaxF = static_cast<double>(UseIntMax);
 304 const double UseUintMaxF = static_cast<double>(UseUintMax);
 305
 306 } // anonymous namespace
 307
 308 bool wxAnyValueTypeImplInt::ConvertValue(const wxAnyValueBuffer& src,
 309                                          wxAnyValueType* dstType,
 310                                          wxAnyValueBuffer& dst) const
 311 {
 312     wxAnyBaseIntType value = GetValue(src);
 313     if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
 314     {
 315 #ifdef wxLongLong_t
 316         wxLongLong ll(value);
 317         wxString s = ll.ToString();
 318 #else
 319         wxString s = wxString::Format(wxS("%ld"), (long)value);
 320 #endif
 321         wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
 322     }
 323     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
 324     {
 325         if ( value < 0 )
 326             return false;
 327         wxAnyBaseUintType ul = (wxAnyBaseUintType) value;
 328         wxAnyValueTypeImplUint::SetValue(ul, dst);
 329     }
 330     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
 331     {
 332         double value2 = static_cast<double>(value);
 333         wxAnyValueTypeImplDouble::SetValue(value2, dst);
 334     }
 335     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
 336     {
 337         bool value2 = value ? true : false;
 338         wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
 339     }
 340     else
 341         return false;
 342
 343     return true;
 344 }
 345
 346 bool wxAnyValueTypeImplUint::ConvertValue(const wxAnyValueBuffer& src,
 347                                           wxAnyValueType* dstType,
 348                                           wxAnyValueBuffer& dst) const
 349 {
 350     wxAnyBaseUintType value = GetValue(src);
 351     if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
 352     {
 353 #ifdef wxLongLong_t
 354         wxULongLong ull(value);
 355         wxString s = ull.ToString();
 356 #else
 357         wxString s = wxString::Format(wxS("%lu"), (long)value);
 358 #endif
 359         wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
 360     }
 361     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
 362     {
 363         if ( value > UseIntMax )
 364             return false;
 365         wxAnyBaseIntType l = (wxAnyBaseIntType) value;
 366         wxAnyValueTypeImplInt::SetValue(l, dst);
 367     }
 368     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
 369     {
 370 #ifndef __VISUALC6__
 371         double value2 = static_cast<double>(value);
 372 #else
 373         // VC6 doesn't implement conversion from unsigned __int64 to double
 374         wxAnyBaseIntType value0 = static_cast<wxAnyBaseIntType>(value);
 375         double value2 = static_cast<double>(value0);
 376 #endif
 377         wxAnyValueTypeImplDouble::SetValue(value2, dst);
 378     }
 379     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
 380     {
 381         bool value2 = value ? true : false;
 382         wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
 383     }
 384     else
 385         return false;
 386
 387     return true;
 388 }
 389
 390 // Convert wxString to destination wxAny value type
 391 bool wxAnyConvertString(const wxString& value,
 392                         wxAnyValueType* dstType,
 393                         wxAnyValueBuffer& dst)
 394 {
 395     if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
 396     {
 397         wxAnyValueTypeImpl<wxString>::SetValue(value, dst);
 398     }
 399     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
 400     {
 401         wxAnyBaseIntType value2;
 402 #ifdef wxLongLong_t
 403         if ( !value.ToLongLong(&value2) )
 404 #else
 405         if ( !value.ToLong(&value2) )
 406 #endif
 407             return false;
 408         wxAnyValueTypeImplInt::SetValue(value2, dst);
 409     }
 410     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
 411     {
 412         wxAnyBaseUintType value2;
 413 #ifdef wxLongLong_t
 414         if ( !value.ToULongLong(&value2) )
 415 #else
 416         if ( !value.ToULong(&value2) )
 417 #endif
 418             return false;
 419         wxAnyValueTypeImplUint::SetValue(value2, dst);
 420     }
 421     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
 422     {
 423         double value2;
 424         if ( !value.ToDouble(&value2) )
 425             return false;
 426         wxAnyValueTypeImplDouble::SetValue(value2, dst);
 427     }
 428     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
 429     {
 430         bool value2;
 431         wxString s(value);
 432         s.MakeLower();
 433         if ( s == wxS("true") ||
 434              s == wxS("yes") ||
 435              s == wxS('1') )
 436             value2 = true;
 437         else if ( s == wxS("false") ||
 438                   s == wxS("no") ||
 439                   s == wxS('0') )
 440             value2 = false;
 441         else
 442             return false;
 443
 444         wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
 445     }
 446     else
 447         return false;
 448
 449     return true;
 450 }
 451
 452 bool wxAnyValueTypeImpl<bool>::ConvertValue(const wxAnyValueBuffer& src,
 453                                             wxAnyValueType* dstType,
 454                                             wxAnyValueBuffer& dst) const
 455 {
 456     bool value = GetValue(src);
 457     if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
 458     {
 459         wxAnyBaseIntType value2 = static_cast<wxAnyBaseIntType>(value);
 460         wxAnyValueTypeImplInt::SetValue(value2, dst);
 461     }
 462     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
 463     {
 464         wxAnyBaseIntType value2 = static_cast<wxAnyBaseUintType>(value);
 465         wxAnyValueTypeImplUint::SetValue(value2, dst);
 466     }
 467     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
 468     {
 469         wxString s;
 470         if ( value )
 471             s = wxS("true");
 472         else
 473             s = wxS("false");
 474         wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
 475     }
 476     else
 477         return false;
 478
 479     return true;
 480 }
 481
 482 bool wxAnyValueTypeImplDouble::ConvertValue(const wxAnyValueBuffer& src,
 483                                             wxAnyValueType* dstType,
 484                                             wxAnyValueBuffer& dst) const
 485 {
 486     double value = GetValue(src);
 487     if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
 488     {
 489         if ( value < UseIntMinF || value > UseIntMaxF )
 490             return false;
 491         wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);
 492         wxAnyValueTypeImplUint::SetValue(ul, dst);
 493     }
 494     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
 495     {
 496         if ( value < 0.0 || value > UseUintMaxF )
 497             return false;
 498         wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);
 499         wxAnyValueTypeImplUint::SetValue(ul, dst);
 500     }
 501     else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
 502     {
 503         wxString s = wxString::Format(wxS("%.14g"), value);
 504         wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
 505     }
 506     else
 507         return false;
 508
 509     return true;
 510 }
 511
 512 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplInt)
 513 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplUint)
 514 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<bool>)
 515 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplDouble)
 516
 517 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplwxString)
 518 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplConstCharPtr)
 519 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplConstWchar_tPtr)
 520
 521 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxDateTime>)
 522 //WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxObject*>)
 523 //WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxArrayString>)
 524
 525 //-------------------------------------------------------------------------
 526 // wxAnyNullValueType implementation
 527 //-------------------------------------------------------------------------
 528
 529 class wxAnyNullValue
 530 {
 531 private:
 532     void*   m_dummy;
 533 };
 534
 535 template <>
 536 class wxAnyValueTypeImpl<wxAnyNullValue> : public wxAnyValueType
 537 {
 538     WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)
 539 public:
 540     // Dummy implementations
 541     virtual void DeleteValue(wxAnyValueBuffer& buf) const
 542     {
 543         wxUnusedVar(buf);
 544     }
 545
 546     virtual void CopyBuffer(const wxAnyValueBuffer& src,
 547                             wxAnyValueBuffer& dst) const
 548     {
 549         wxUnusedVar(src);
 550         wxUnusedVar(dst);
 551     }
 552
 553     virtual bool ConvertValue(const wxAnyValueBuffer& src,
 554                               wxAnyValueType* dstType,
 555                               wxAnyValueBuffer& dst) const
 556     {
 557         wxUnusedVar(src);
 558         wxUnusedVar(dstType);
 559         wxUnusedVar(dst);
 560         return false;
 561     }
 562
 563 private:
 564 };
 565
 566 WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)
 567
 568 wxAnyValueType* wxAnyNullValueType =
 569     wxAnyValueTypeImpl<wxAnyNullValue>::GetInstance();
 570
 571 #endif // wxUSE_ANY