src/common/variant.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/variant.cpp
   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)
   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/variant.h"
  20
  21 #if wxUSE_VARIANT
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/string.h"
  25     #include "wx/math.h"
  26     #include "wx/crt.h"
  27     #if wxUSE_STREAMS
  28         #include "wx/stream.h"
  29     #endif
  30 #endif
  31
  32 #if wxUSE_STD_IOSTREAM
  33     #if wxUSE_IOSTREAMH
  34         #include <fstream.h>
  35     #else
  36         #include <fstream>
  37     #endif
  38 #endif
  39
  40 #if defined(__MWERKS__) && __MSL__ >= 0x6000
  41 namespace std {}
  42 using namespace std ;
  43 #endif
  44
  45 #if wxUSE_STREAMS
  46     #include "wx/txtstrm.h"
  47 #endif
  48
  49 #include "wx/string.h"
  50 #include "wx/tokenzr.h"
  51
  52 wxVariant WXDLLIMPEXP_BASE wxNullVariant;
  53
  54
  55 #include "wx/listimpl.cpp"
  56 WX_DEFINE_LIST(wxVariantList)
  57
  58 /*
  59  * wxVariant
  60  */
  61
  62 IMPLEMENT_DYNAMIC_CLASS(wxVariant, wxObject)
  63
  64 wxVariant::wxVariant()
  65 {
  66     m_data = (wxVariantData*) NULL;
  67 }
  68
  69 bool wxVariant::IsNull() const
  70 {
  71      return (m_data == (wxVariantData*) NULL);
  72 }
  73
  74 void wxVariant::MakeNull()
  75 {
  76     UnRef();
  77 }
  78
  79 void wxVariant::Clear()
  80 {
  81     m_name = wxEmptyString;
  82 }
  83
  84 wxVariant::wxVariant(const wxVariant& variant)
  85     : wxObject()
  86 {
  87     m_data = (wxVariantData*) NULL;
  88
  89     if (!variant.IsNull())
  90         Ref(variant);
  91
  92     m_name = variant.m_name;
  93 }
  94
  95 wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
  96 {
  97     m_data = data;
  98     m_name = name;
  99 }
 100
 101 wxVariant::~wxVariant()
 102 {
 103     UnRef();
 104 }
 105
 106 // Assignment
 107 void wxVariant::operator= (const wxVariant& variant)
 108 {
 109     Ref(variant);
 110     m_name = variant.m_name;
 111 }
 112
 113 // myVariant = new wxStringVariantData("hello")
 114 void wxVariant::operator= (wxVariantData* variantData)
 115 {
 116     UnRef();
 117     m_data = variantData;
 118 }
 119
 120 bool wxVariant::operator== (const wxVariant& variant) const
 121 {
 122     if (IsNull() || variant.IsNull())
 123         return (IsNull() == variant.IsNull());
 124
 125     if (GetType() != variant.GetType())
 126         return false;
 127
 128     return (GetData()->Eq(* variant.GetData()));
 129 }
 130
 131 bool wxVariant::operator!= (const wxVariant& variant) const
 132 {
 133     return (!(*this == variant));
 134 }
 135
 136 wxString wxVariant::MakeString() const
 137 {
 138     if (!IsNull())
 139     {
 140         wxString str;
 141         if (GetData()->Write(str))
 142             return str;
 143     }
 144     return wxEmptyString;
 145 }
 146
 147 void wxVariant::SetData(wxVariantData* data)
 148 {
 149     UnRef();
 150     m_data = data;
 151 }
 152
 153 void wxVariant::Ref(const wxVariant& clone)
 154 {
 155     // nothing to be done
 156     if (m_data == clone.m_data)
 157         return;
 158
 159     // delete reference to old data
 160     UnRef();
 161
 162     // reference new data
 163     if ( clone.m_data )
 164     {
 165         m_data = clone.m_data;
 166         m_data->m_count++;
 167     }
 168 }
 169
 170
 171 void wxVariant::UnRef()
 172 {
 173     if ( m_data )
 174     {
 175         wxASSERT_MSG( m_data->m_count > 0, _T("invalid ref data count") );
 176
 177         m_data->DecRef();
 178         m_data = NULL;
 179     }
 180 }
 181
 182 bool wxVariant::Unshare()
 183 {
 184     if ( m_data && m_data->GetRefCount() > 1 )
 185     {
 186         // note that ref is not going to be destroyed in this case...
 187         const wxVariantData* ref = m_data;
 188         UnRef();
 189
 190         // ... so we can still access it
 191         m_data = ref->Clone();
 192
 193         wxASSERT_MSG( (m_data && m_data->GetRefCount() == 1),
 194                   _T("wxVariant::AllocExclusive() failed.") );
 195
 196         if (!m_data || m_data->GetRefCount() != 1)
 197             return false;
 198         else
 199             return true;
 200     }
 201     //else: data is null or ref count is 1, so we are exclusive owners of m_refData anyhow
 202     else
 203         return true;
 204 }
 205
 206
 207 // Returns a string representing the type of the variant,
 208 // e.g. "string", "bool", "list", "double", "long"
 209 wxString wxVariant::GetType() const
 210 {
 211     if (IsNull())
 212         return wxString(wxT("null"));
 213     else
 214         return GetData()->GetType();
 215 }
 216
 217
 218 bool wxVariant::IsType(const wxString& type) const
 219 {
 220     return (GetType() == type);
 221 }
 222
 223 bool wxVariant::IsValueKindOf(const wxClassInfo* type) const
 224 {
 225     wxClassInfo* info=GetData()->GetValueClassInfo();
 226     return info ? info->IsKindOf(type) : false ;
 227 }
 228
 229
 230 // -----------------------------------------------------------------
 231 // wxVariantDataLong
 232 // -----------------------------------------------------------------
 233
 234 class WXDLLIMPEXP_BASE wxVariantDataLong: public wxVariantData
 235 {
 236 public:
 237     wxVariantDataLong() { m_value = 0; }
 238     wxVariantDataLong(long value) { m_value = value; }
 239
 240     inline long GetValue() const { return m_value; }
 241     inline void SetValue(long value) { m_value = value; }
 242
 243     virtual bool Eq(wxVariantData& data) const;
 244
 245     virtual bool Read(wxString& str);
 246     virtual bool Write(wxString& str) const;
 247 #if wxUSE_STD_IOSTREAM
 248     virtual bool Read(wxSTD istream& str);
 249     virtual bool Write(wxSTD ostream& str) const;
 250 #endif
 251 #if wxUSE_STREAMS
 252     virtual bool Read(wxInputStream& str);
 253     virtual bool Write(wxOutputStream &str) const;
 254 #endif // wxUSE_STREAMS
 255
 256     wxVariantData* Clone() const { return new wxVariantDataLong(m_value); }
 257
 258     virtual wxString GetType() const { return wxT("long"); }
 259
 260 protected:
 261     long m_value;
 262 };
 263
 264 bool wxVariantDataLong::Eq(wxVariantData& data) const
 265 {
 266     wxASSERT_MSG( (data.GetType() == wxT("long")), wxT("wxVariantDataLong::Eq: argument mismatch") );
 267
 268     wxVariantDataLong& otherData = (wxVariantDataLong&) data;
 269
 270     return (otherData.m_value == m_value);
 271 }
 272
 273 #if wxUSE_STD_IOSTREAM
 274 bool wxVariantDataLong::Write(wxSTD ostream& str) const
 275 {
 276     wxString s;
 277     Write(s);
 278     str << (const char*) s.mb_str();
 279     return true;
 280 }
 281 #endif
 282
 283 bool wxVariantDataLong::Write(wxString& str) const
 284 {
 285     str.Printf(wxT("%ld"), m_value);
 286     return true;
 287 }
 288
 289 #if wxUSE_STD_IOSTREAM
 290 bool wxVariantDataLong::Read(wxSTD istream& str)
 291 {
 292     str >> m_value;
 293     return true;
 294 }
 295 #endif
 296
 297 #if wxUSE_STREAMS
 298 bool wxVariantDataLong::Write(wxOutputStream& str) const
 299 {
 300     wxTextOutputStream s(str);
 301
 302     s.Write32((size_t)m_value);
 303     return true;
 304 }
 305
 306 bool wxVariantDataLong::Read(wxInputStream& str)
 307 {
 308    wxTextInputStream s(str);
 309    m_value = s.Read32();
 310    return true;
 311 }
 312 #endif // wxUSE_STREAMS
 313
 314 bool wxVariantDataLong::Read(wxString& str)
 315 {
 316     m_value = wxAtol(str);
 317     return true;
 318 }
 319
 320 // wxVariant
 321
 322 wxVariant::wxVariant(long val, const wxString& name)
 323 {
 324     m_data = new wxVariantDataLong(val);
 325     m_name = name;
 326 }
 327
 328 wxVariant::wxVariant(int val, const wxString& name)
 329 {
 330     m_data = new wxVariantDataLong((long)val);
 331     m_name = name;
 332 }
 333
 334 wxVariant::wxVariant(short val, const wxString& name)
 335 {
 336     m_data = new wxVariantDataLong((long)val);
 337     m_name = name;
 338 }
 339
 340 bool wxVariant::operator== (long value) const
 341 {
 342     long thisValue;
 343     if (!Convert(&thisValue))
 344         return false;
 345     else
 346         return (value == thisValue);
 347 }
 348
 349 bool wxVariant::operator!= (long value) const
 350 {
 351     return (!((*this) == value));
 352 }
 353
 354 void wxVariant::operator= (long value)
 355 {
 356     if (GetType() == wxT("long") &&
 357         m_data->GetRefCount() == 1)
 358     {
 359         ((wxVariantDataLong*)GetData())->SetValue(value);
 360     }
 361     else
 362     {
 363         UnRef();
 364         m_data = new wxVariantDataLong(value);
 365     }
 366 }
 367
 368 long wxVariant::GetLong() const
 369 {
 370     long value;
 371     if (Convert(& value))
 372         return value;
 373     else
 374     {
 375         wxFAIL_MSG(wxT("Could not convert to a long"));
 376         return 0;
 377     }
 378 }
 379
 380 // -----------------------------------------------------------------
 381 // wxVariantDoubleData
 382 // -----------------------------------------------------------------
 383
 384 class WXDLLIMPEXP_BASE wxVariantDoubleData: public wxVariantData
 385 {
 386 public:
 387     wxVariantDoubleData() { m_value = 0.0; }
 388     wxVariantDoubleData(double value) { m_value = value; }
 389
 390     inline double GetValue() const { return m_value; }
 391     inline void SetValue(double value) { m_value = value; }
 392
 393     virtual bool Eq(wxVariantData& data) const;
 394     virtual bool Read(wxString& str);
 395 #if wxUSE_STD_IOSTREAM
 396     virtual bool Write(wxSTD ostream& str) const;
 397 #endif
 398     virtual bool Write(wxString& str) const;
 399 #if wxUSE_STD_IOSTREAM
 400     virtual bool Read(wxSTD istream& str);
 401 #endif
 402 #if wxUSE_STREAMS
 403     virtual bool Read(wxInputStream& str);
 404     virtual bool Write(wxOutputStream &str) const;
 405 #endif // wxUSE_STREAMS
 406     virtual wxString GetType() const { return wxT("double"); }
 407
 408     wxVariantData* Clone() const { return new wxVariantDoubleData(m_value); }
 409 protected:
 410     double m_value;
 411 };
 412
 413 bool wxVariantDoubleData::Eq(wxVariantData& data) const
 414 {
 415     wxASSERT_MSG( (data.GetType() == wxT("double")), wxT("wxVariantDoubleData::Eq: argument mismatch") );
 416
 417     wxVariantDoubleData& otherData = (wxVariantDoubleData&) data;
 418
 419     return wxIsSameDouble(otherData.m_value, m_value);
 420 }
 421
 422 #if wxUSE_STD_IOSTREAM
 423 bool wxVariantDoubleData::Write(wxSTD ostream& str) const
 424 {
 425     wxString s;
 426     Write(s);
 427     str << (const char*) s.mb_str();
 428     return true;
 429 }
 430 #endif
 431
 432 bool wxVariantDoubleData::Write(wxString& str) const
 433 {
 434     str.Printf(wxT("%.14g"), m_value);
 435     return true;
 436 }
 437
 438 #if wxUSE_STD_IOSTREAM
 439 bool wxVariantDoubleData::Read(wxSTD istream& str)
 440 {
 441     str >> m_value;
 442     return true;
 443 }
 444 #endif
 445
 446 #if wxUSE_STREAMS
 447 bool wxVariantDoubleData::Write(wxOutputStream& str) const
 448 {
 449     wxTextOutputStream s(str);
 450     s.WriteDouble((double)m_value);
 451     return true;
 452 }
 453
 454 bool wxVariantDoubleData::Read(wxInputStream& str)
 455 {
 456     wxTextInputStream s(str);
 457     m_value = (float)s.ReadDouble();
 458     return true;
 459 }
 460 #endif // wxUSE_STREAMS
 461
 462 bool wxVariantDoubleData::Read(wxString& str)
 463 {
 464     m_value = wxAtof(str);
 465     return true;
 466 }
 467
 468 //  wxVariant double code
 469
 470 wxVariant::wxVariant(double val, const wxString& name)
 471 {
 472     m_data = new wxVariantDoubleData(val);
 473     m_name = name;
 474 }
 475
 476 bool wxVariant::operator== (double value) const
 477 {
 478     double thisValue;
 479     if (!Convert(&thisValue))
 480         return false;
 481
 482     return wxIsSameDouble(value, thisValue);
 483 }
 484
 485 bool wxVariant::operator!= (double value) const
 486 {
 487     return (!((*this) == value));
 488 }
 489
 490 void wxVariant::operator= (double value)
 491 {
 492     if (GetType() == wxT("double") &&
 493         m_data->GetRefCount() == 1)
 494     {
 495         ((wxVariantDoubleData*)GetData())->SetValue(value);
 496     }
 497     else
 498     {
 499         UnRef();
 500         m_data = new wxVariantDoubleData(value);
 501     }
 502 }
 503
 504 double wxVariant::GetDouble() const
 505 {
 506     double value;
 507     if (Convert(& value))
 508         return value;
 509     else
 510     {
 511         wxFAIL_MSG(wxT("Could not convert to a double number"));
 512         return 0.0;
 513     }
 514 }
 515
 516 // -----------------------------------------------------------------
 517 // wxVariantBoolData
 518 // -----------------------------------------------------------------
 519
 520 class WXDLLIMPEXP_BASE wxVariantDataBool: public wxVariantData
 521 {
 522 public:
 523     wxVariantDataBool() { m_value = 0; }
 524     wxVariantDataBool(bool value) { m_value = value; }
 525
 526     inline bool GetValue() const { return m_value; }
 527     inline void SetValue(bool value) { m_value = value; }
 528
 529     virtual bool Eq(wxVariantData& data) const;
 530 #if wxUSE_STD_IOSTREAM
 531     virtual bool Write(wxSTD ostream& str) const;
 532 #endif
 533     virtual bool Write(wxString& str) const;
 534     virtual bool Read(wxString& str);
 535 #if wxUSE_STD_IOSTREAM
 536     virtual bool Read(wxSTD istream& str);
 537 #endif
 538 #if wxUSE_STREAMS
 539     virtual bool Read(wxInputStream& str);
 540     virtual bool Write(wxOutputStream& str) const;
 541 #endif // wxUSE_STREAMS
 542     virtual wxString GetType() const { return wxT("bool"); }
 543
 544     wxVariantData* Clone() const { return new wxVariantDataBool(m_value); }
 545 protected:
 546     bool m_value;
 547 };
 548
 549 bool wxVariantDataBool::Eq(wxVariantData& data) const
 550 {
 551     wxASSERT_MSG( (data.GetType() == wxT("bool")), wxT("wxVariantDataBool::Eq: argument mismatch") );
 552
 553     wxVariantDataBool& otherData = (wxVariantDataBool&) data;
 554
 555     return (otherData.m_value == m_value);
 556 }
 557
 558 #if wxUSE_STD_IOSTREAM
 559 bool wxVariantDataBool::Write(wxSTD ostream& str) const
 560 {
 561     wxString s;
 562     Write(s);
 563     str << (const char*) s.mb_str();
 564     return true;
 565 }
 566 #endif
 567
 568 bool wxVariantDataBool::Write(wxString& str) const
 569 {
 570     str.Printf(wxT("%d"), (int) m_value);
 571     return true;
 572 }
 573
 574 #if wxUSE_STD_IOSTREAM
 575 bool wxVariantDataBool::Read(wxSTD istream& WXUNUSED(str))
 576 {
 577     wxFAIL_MSG(wxT("Unimplemented"));
 578 //    str >> (long) m_value;
 579     return false;
 580 }
 581 #endif
 582
 583 #if wxUSE_STREAMS
 584 bool wxVariantDataBool::Write(wxOutputStream& str) const
 585 {
 586     wxTextOutputStream s(str);
 587
 588     s.Write8(m_value);
 589     return true;
 590 }
 591
 592 bool wxVariantDataBool::Read(wxInputStream& str)
 593 {
 594     wxTextInputStream s(str);
 595
 596     m_value = s.Read8() != 0;
 597     return true;
 598 }
 599 #endif // wxUSE_STREAMS
 600
 601 bool wxVariantDataBool::Read(wxString& str)
 602 {
 603     m_value = (wxAtol(str) != 0);
 604     return true;
 605 }
 606
 607 // wxVariant ****
 608
 609 wxVariant::wxVariant(bool val, const wxString& name)
 610 {
 611     m_data = new wxVariantDataBool(val);
 612     m_name = name;
 613 }
 614
 615 bool wxVariant::operator== (bool value) const
 616 {
 617     bool thisValue;
 618     if (!Convert(&thisValue))
 619         return false;
 620     else
 621         return (value == thisValue);
 622 }
 623
 624 bool wxVariant::operator!= (bool value) const
 625 {
 626     return (!((*this) == value));
 627 }
 628
 629 void wxVariant::operator= (bool value)
 630 {
 631     if (GetType() == wxT("bool") &&
 632         m_data->GetRefCount() == 1)
 633     {
 634         ((wxVariantDataBool*)GetData())->SetValue(value);
 635     }
 636     else
 637     {
 638         UnRef();
 639         m_data = new wxVariantDataBool(value);
 640     }
 641 }
 642
 643 bool wxVariant::GetBool() const
 644 {
 645     bool value;
 646     if (Convert(& value))
 647         return value;
 648     else
 649     {
 650         wxFAIL_MSG(wxT("Could not convert to a bool"));
 651         return 0;
 652     }
 653 }
 654
 655 // -----------------------------------------------------------------
 656 // wxVariantDataChar
 657 // -----------------------------------------------------------------
 658
 659 class WXDLLIMPEXP_BASE wxVariantDataChar: public wxVariantData
 660 {
 661 public:
 662     wxVariantDataChar() { m_value = 0; }
 663     wxVariantDataChar(const wxUniChar& value) { m_value = value; }
 664
 665     inline wxUniChar GetValue() const { return m_value; }
 666     inline void SetValue(const wxUniChar& value) { m_value = value; }
 667
 668     virtual bool Eq(wxVariantData& data) const;
 669 #if wxUSE_STD_IOSTREAM
 670     virtual bool Read(wxSTD istream& str);
 671     virtual bool Write(wxSTD ostream& str) const;
 672 #endif
 673     virtual bool Read(wxString& str);
 674     virtual bool Write(wxString& str) const;
 675 #if wxUSE_STREAMS
 676     virtual bool Read(wxInputStream& str);
 677     virtual bool Write(wxOutputStream& str) const;
 678 #endif // wxUSE_STREAMS
 679     virtual wxString GetType() const { return wxT("char"); }
 680     wxVariantData* Clone() const { return new wxVariantDataChar(m_value); }
 681
 682 protected:
 683     wxUniChar m_value;
 684 };
 685
 686 bool wxVariantDataChar::Eq(wxVariantData& data) const
 687 {
 688     wxASSERT_MSG( (data.GetType() == wxT("char")), wxT("wxVariantDataChar::Eq: argument mismatch") );
 689
 690     wxVariantDataChar& otherData = (wxVariantDataChar&) data;
 691
 692     return (otherData.m_value == m_value);
 693 }
 694
 695 #if wxUSE_STD_IOSTREAM
 696 bool wxVariantDataChar::Write(wxSTD ostream& str) const
 697 {
 698     str << wxString(m_value);
 699     return true;
 700 }
 701 #endif
 702
 703 bool wxVariantDataChar::Write(wxString& str) const
 704 {
 705     str = m_value;
 706     return true;
 707 }
 708
 709 #if wxUSE_STD_IOSTREAM
 710 bool wxVariantDataChar::Read(wxSTD istream& WXUNUSED(str))
 711 {
 712     wxFAIL_MSG(wxT("Unimplemented"));
 713
 714     return false;
 715 }
 716 #endif
 717
 718 #if wxUSE_STREAMS
 719 bool wxVariantDataChar::Write(wxOutputStream& str) const
 720 {
 721     wxTextOutputStream s(str);
 722
 723     // FIXME-UTF8: this should be just "s << m_value;" after removal of
 724     //             ANSI build and addition of wxUniChar to wxTextOutputStream:
 725     s << (wxChar)m_value;
 726
 727     return true;
 728 }
 729
 730 bool wxVariantDataChar::Read(wxInputStream& str)
 731 {
 732     wxTextInputStream s(str);
 733
 734     // FIXME-UTF8: this should be just "s >> m_value;" after removal of
 735     //             ANSI build and addition of wxUniChar to wxTextInputStream:
 736     wxChar ch;
 737     s >> ch;
 738     m_value = ch;
 739
 740     return true;
 741 }
 742 #endif // wxUSE_STREAMS
 743
 744 bool wxVariantDataChar::Read(wxString& str)
 745 {
 746     m_value = str[0u];
 747     return true;
 748 }
 749
 750 wxVariant::wxVariant(const wxUniChar& val, const wxString& name)
 751 {
 752     m_data = new wxVariantDataChar(val);
 753     m_name = name;
 754 }
 755
 756 wxVariant::wxVariant(char val, const wxString& name)
 757 {
 758     m_data = new wxVariantDataChar(val);
 759     m_name = name;
 760 }
 761
 762 wxVariant::wxVariant(wchar_t val, const wxString& name)
 763 {
 764     m_data = new wxVariantDataChar(val);
 765     m_name = name;
 766 }
 767
 768 bool wxVariant::operator==(const wxUniChar& value) const
 769 {
 770     wxUniChar thisValue;
 771     if (!Convert(&thisValue))
 772         return false;
 773     else
 774         return (value == thisValue);
 775 }
 776
 777 wxVariant& wxVariant::operator=(const wxUniChar& value)
 778 {
 779     if (GetType() == wxT("char") &&
 780         m_data->GetRefCount() == 1)
 781     {
 782         ((wxVariantDataChar*)GetData())->SetValue(value);
 783     }
 784     else
 785     {
 786         UnRef();
 787         m_data = new wxVariantDataChar(value);
 788     }
 789
 790     return *this;
 791 }
 792
 793 wxUniChar wxVariant::GetChar() const
 794 {
 795     wxUniChar value;
 796     if (Convert(& value))
 797         return value;
 798     else
 799     {
 800         wxFAIL_MSG(wxT("Could not convert to a char"));
 801         return wxUniChar(0);
 802     }
 803 }
 804
 805 // ----------------------------------------------------------------------------
 806 // wxVariantDataString
 807 // ----------------------------------------------------------------------------
 808
 809 class WXDLLIMPEXP_BASE wxVariantDataString: public wxVariantData
 810 {
 811 public:
 812     wxVariantDataString() { }
 813     wxVariantDataString(const wxString& value) { m_value = value; }
 814
 815     inline wxString GetValue() const { return m_value; }
 816     inline void SetValue(const wxString& value) { m_value = value; }
 817
 818     virtual bool Eq(wxVariantData& data) const;
 819 #if wxUSE_STD_IOSTREAM
 820     virtual bool Write(wxSTD ostream& str) const;
 821 #endif
 822     virtual bool Read(wxString& str);
 823     virtual bool Write(wxString& str) const;
 824 #if wxUSE_STD_IOSTREAM
 825     virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
 826 #endif
 827 #if wxUSE_STREAMS
 828     virtual bool Read(wxInputStream& str);
 829     virtual bool Write(wxOutputStream& str) const;
 830 #endif // wxUSE_STREAMS
 831     virtual wxString GetType() const { return wxT("string"); }
 832     wxVariantData* Clone() const { return new wxVariantDataString(m_value); }
 833
 834 protected:
 835     wxString m_value;
 836 };
 837
 838 bool wxVariantDataString::Eq(wxVariantData& data) const
 839 {
 840     wxASSERT_MSG( (data.GetType() == wxT("string")), wxT("wxVariantDataString::Eq: argument mismatch") );
 841
 842     wxVariantDataString& otherData = (wxVariantDataString&) data;
 843
 844     return (otherData.m_value == m_value);
 845 }
 846
 847 #if wxUSE_STD_IOSTREAM
 848 bool wxVariantDataString::Write(wxSTD ostream& str) const
 849 {
 850     str << (const char*) m_value.mb_str();
 851     return true;
 852 }
 853 #endif
 854
 855 bool wxVariantDataString::Write(wxString& str) const
 856 {
 857     str = m_value;
 858     return true;
 859 }
 860
 861 #if wxUSE_STREAMS
 862 bool wxVariantDataString::Write(wxOutputStream& str) const
 863 {
 864   // why doesn't wxOutputStream::operator<< take "const wxString&"
 865     wxTextOutputStream s(str);
 866     s.WriteString(m_value);
 867     return true;
 868 }
 869
 870 bool wxVariantDataString::Read(wxInputStream& str)
 871 {
 872     wxTextInputStream s(str);
 873
 874     m_value = s.ReadLine();
 875     return true;
 876 }
 877 #endif // wxUSE_STREAMS
 878
 879 bool wxVariantDataString::Read(wxString& str)
 880 {
 881     m_value = str;
 882     return true;
 883 }
 884
 885 // wxVariant ****
 886
 887 wxVariant::wxVariant(const wxString& val, const wxString& name)
 888 {
 889     m_data = new wxVariantDataString(val);
 890     m_name = name;
 891 }
 892
 893 wxVariant::wxVariant(const char* val, const wxString& name)
 894 {
 895     m_data = new wxVariantDataString(wxString(val));
 896     m_name = name;
 897 }
 898
 899 wxVariant::wxVariant(const wchar_t* val, const wxString& name)
 900 {
 901     m_data = new wxVariantDataString(wxString(val));
 902     m_name = name;
 903 }
 904
 905 wxVariant::wxVariant(const wxCStrData& val, const wxString& name)
 906 {
 907     m_data = new wxVariantDataString(val.AsString());
 908     m_name = name;
 909 }
 910
 911 wxVariant::wxVariant(const wxCharBuffer& val, const wxString& name)
 912 {
 913     m_data = new wxVariantDataString(wxString(val));
 914     m_name = name;
 915 }
 916
 917 wxVariant::wxVariant(const wxWCharBuffer& val, const wxString& name)
 918 {
 919     m_data = new wxVariantDataString(wxString(val));
 920     m_name = name;
 921 }
 922
 923 bool wxVariant::operator== (const wxString& value) const
 924 {
 925     wxString thisValue;
 926     if (!Convert(&thisValue))
 927         return false;
 928
 929     return value == thisValue;
 930 }
 931
 932 bool wxVariant::operator!= (const wxString& value) const
 933 {
 934     return (!((*this) == value));
 935 }
 936
 937 wxVariant& wxVariant::operator= (const wxString& value)
 938 {
 939     if (GetType() == wxT("string") &&
 940         m_data->GetRefCount() == 1)
 941     {
 942         ((wxVariantDataString*)GetData())->SetValue(value);
 943     }
 944     else
 945     {
 946         UnRef();
 947         m_data = new wxVariantDataString(value);
 948     }
 949     return *this;
 950 }
 951
 952 wxString wxVariant::GetString() const
 953 {
 954     wxString value;
 955     if (!Convert(& value))
 956     {
 957         wxFAIL_MSG(wxT("Could not convert to a string"));
 958     }
 959
 960     return value;
 961 }
 962
 963 // ----------------------------------------------------------------------------
 964 // wxVariantDataWxObjectPtr
 965 // ----------------------------------------------------------------------------
 966
 967 class wxVariantDataWxObjectPtr: public wxVariantData
 968 {
 969 public:
 970     wxVariantDataWxObjectPtr() { }
 971     wxVariantDataWxObjectPtr(wxObject* value) { m_value = value; }
 972
 973     inline wxObject* GetValue() const { return m_value; }
 974     inline void SetValue(wxObject* value) { m_value = value; }
 975
 976     virtual bool Eq(wxVariantData& data) const;
 977 #if wxUSE_STD_IOSTREAM
 978     virtual bool Write(wxSTD ostream& str) const;
 979 #endif
 980     virtual bool Write(wxString& str) const;
 981 #if wxUSE_STD_IOSTREAM
 982     virtual bool Read(wxSTD istream& str);
 983 #endif
 984     virtual bool Read(wxString& str);
 985     virtual wxString GetType() const ;
 986     virtual wxVariantData* Clone() const { return new wxVariantDataWxObjectPtr(m_value); }
 987
 988     virtual wxClassInfo* GetValueClassInfo();
 989
 990 protected:
 991     wxObject* m_value;
 992 };
 993
 994 bool wxVariantDataWxObjectPtr::Eq(wxVariantData& data) const
 995 {
 996     wxASSERT_MSG( data.GetType() == GetType(), wxT("wxVariantDataWxObjectPtr::Eq: argument mismatch") );
 997
 998     wxVariantDataWxObjectPtr& otherData = (wxVariantDataWxObjectPtr&) data;
 999
1000     return (otherData.m_value == m_value);
1001 }
1002
1003 wxString wxVariantDataWxObjectPtr::GetType() const
1004 {
1005     wxString returnVal(wxT("wxObject*"));
1006
1007     if (m_value)
1008     {
1009         returnVal = m_value->GetClassInfo()->GetClassName();
1010         returnVal += wxT("*");
1011     }
1012
1013     return returnVal;
1014 }
1015
1016 wxClassInfo* wxVariantDataWxObjectPtr::GetValueClassInfo()
1017 {
1018     wxClassInfo* returnVal=NULL;
1019
1020     if (m_value) returnVal = m_value->GetClassInfo();
1021
1022     return returnVal;
1023 }
1024
1025 #if wxUSE_STD_IOSTREAM
1026 bool wxVariantDataWxObjectPtr::Write(wxSTD ostream& str) const
1027 {
1028     wxString s;
1029     Write(s);
1030     str << (const char*) s.mb_str();
1031     return true;
1032 }
1033 #endif
1034
1035 bool wxVariantDataWxObjectPtr::Write(wxString& str) const
1036 {
1037     str.Printf(wxT("%s(%p)"), GetType().c_str(), static_cast<void*>(m_value));
1038     return true;
1039 }
1040
1041 #if wxUSE_STD_IOSTREAM
1042 bool wxVariantDataWxObjectPtr::Read(wxSTD istream& WXUNUSED(str))
1043 {
1044     // Not implemented
1045     return false;
1046 }
1047 #endif
1048
1049 bool wxVariantDataWxObjectPtr::Read(wxString& WXUNUSED(str))
1050 {
1051     // Not implemented
1052     return false;
1053 }
1054
1055 // wxVariant
1056
1057 wxVariant::wxVariant( wxObject* val, const wxString& name)
1058 {
1059     m_data = new wxVariantDataWxObjectPtr(val);
1060     m_name = name;
1061 }
1062
1063 bool wxVariant::operator== (wxObject* value) const
1064 {
1065     return (value == ((wxVariantDataWxObjectPtr*)GetData())->GetValue());
1066 }
1067
1068 bool wxVariant::operator!= (wxObject* value) const
1069 {
1070     return (!((*this) == (wxObject*) value));
1071 }
1072
1073 void wxVariant::operator= (wxObject* value)
1074 {
1075     UnRef();
1076     m_data = new wxVariantDataWxObjectPtr(value);
1077 }
1078
1079 wxObject* wxVariant::GetWxObjectPtr() const
1080 {
1081     return (wxObject*) ((wxVariantDataWxObjectPtr*) m_data)->GetValue();
1082 }
1083
1084 // ----------------------------------------------------------------------------
1085 // wxVariantDataVoidPtr
1086 // ----------------------------------------------------------------------------
1087
1088 class wxVariantDataVoidPtr: public wxVariantData
1089 {
1090 public:
1091     wxVariantDataVoidPtr() { }
1092     wxVariantDataVoidPtr(void* value) { m_value = value; }
1093
1094     inline void* GetValue() const { return m_value; }
1095     inline void SetValue(void* value) { m_value = value; }
1096
1097     virtual bool Eq(wxVariantData& data) const;
1098 #if wxUSE_STD_IOSTREAM
1099     virtual bool Write(wxSTD ostream& str) const;
1100 #endif
1101     virtual bool Write(wxString& str) const;
1102 #if wxUSE_STD_IOSTREAM
1103     virtual bool Read(wxSTD istream& str);
1104 #endif
1105     virtual bool Read(wxString& str);
1106     virtual wxString GetType() const { return wxT("void*"); }
1107     virtual wxVariantData* Clone() const { return new wxVariantDataVoidPtr(m_value); }
1108
1109 protected:
1110     void* m_value;
1111 };
1112
1113 bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const
1114 {
1115     wxASSERT_MSG( data.GetType() == wxT("void*"), wxT("wxVariantDataVoidPtr::Eq: argument mismatch") );
1116
1117     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
1118
1119     return (otherData.m_value == m_value);
1120 }
1121
1122 #if wxUSE_STD_IOSTREAM
1123 bool wxVariantDataVoidPtr::Write(wxSTD ostream& str) const
1124 {
1125     wxString s;
1126     Write(s);
1127     str << (const char*) s.mb_str();
1128     return true;
1129 }
1130 #endif
1131
1132 bool wxVariantDataVoidPtr::Write(wxString& str) const
1133 {
1134     str.Printf(wxT("%p"), m_value);
1135     return true;
1136 }
1137
1138 #if wxUSE_STD_IOSTREAM
1139 bool wxVariantDataVoidPtr::Read(wxSTD istream& WXUNUSED(str))
1140 {
1141     // Not implemented
1142     return false;
1143 }
1144 #endif
1145
1146 bool wxVariantDataVoidPtr::Read(wxString& WXUNUSED(str))
1147 {
1148     // Not implemented
1149     return false;
1150 }
1151
1152 // wxVariant
1153
1154 wxVariant::wxVariant( void* val, const wxString& name)
1155 {
1156     m_data = new wxVariantDataVoidPtr(val);
1157     m_name = name;
1158 }
1159
1160 bool wxVariant::operator== (void* value) const
1161 {
1162     return (value == ((wxVariantDataVoidPtr*)GetData())->GetValue());
1163 }
1164
1165 bool wxVariant::operator!= (void* value) const
1166 {
1167     return (!((*this) == (void*) value));
1168 }
1169
1170 void wxVariant::operator= (void* value)
1171 {
1172     if (GetType() == wxT("void*") && (m_data->GetRefCount() == 1))
1173     {
1174         ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
1175     }
1176     else
1177     {
1178         UnRef();
1179         m_data = new wxVariantDataVoidPtr(value);
1180     }
1181 }
1182
1183 void* wxVariant::GetVoidPtr() const
1184 {
1185     wxASSERT( (GetType() == wxT("void*")) );
1186
1187     return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
1188 }
1189
1190 // ----------------------------------------------------------------------------
1191 // wxVariantDataDateTime
1192 // ----------------------------------------------------------------------------
1193
1194 #if wxUSE_DATETIME
1195
1196 class wxVariantDataDateTime: public wxVariantData
1197 {
1198 public:
1199     wxVariantDataDateTime() { }
1200     wxVariantDataDateTime(const wxDateTime& value) { m_value = value; }
1201
1202     inline wxDateTime GetValue() const { return m_value; }
1203     inline void SetValue(const wxDateTime& value) { m_value = value; }
1204
1205     virtual bool Eq(wxVariantData& data) const;
1206 #if wxUSE_STD_IOSTREAM
1207     virtual bool Write(wxSTD ostream& str) const;
1208 #endif
1209     virtual bool Write(wxString& str) const;
1210 #if wxUSE_STD_IOSTREAM
1211     virtual bool Read(wxSTD istream& str);
1212 #endif
1213     virtual bool Read(wxString& str);
1214     virtual wxString GetType() const { return wxT("datetime"); }
1215     virtual wxVariantData* Clone() const { return new wxVariantDataDateTime(m_value); }
1216
1217 protected:
1218     wxDateTime m_value;
1219 };
1220
1221
1222 bool wxVariantDataDateTime::Eq(wxVariantData& data) const
1223 {
1224     wxASSERT_MSG( (data.GetType() == wxT("datetime")), wxT("wxVariantDataDateTime::Eq: argument mismatch") );
1225
1226     wxVariantDataDateTime& otherData = (wxVariantDataDateTime&) data;
1227
1228     return (otherData.m_value == m_value);
1229 }
1230
1231
1232 #if wxUSE_STD_IOSTREAM
1233 bool wxVariantDataDateTime::Write(wxSTD ostream& str) const
1234 {
1235     wxString value;
1236     Write( value );
1237     str << value.c_str();
1238     return true;
1239 }
1240 #endif
1241
1242
1243 bool wxVariantDataDateTime::Write(wxString& str) const
1244 {
1245     str = m_value.Format();
1246     return true;
1247 }
1248
1249
1250 #if wxUSE_STD_IOSTREAM
1251 bool wxVariantDataDateTime::Read(wxSTD istream& WXUNUSED(str))
1252 {
1253     // Not implemented
1254     return false;
1255 }
1256 #endif
1257
1258
1259 bool wxVariantDataDateTime::Read(wxString& str)
1260 {
1261     if(! m_value.ParseDateTime(str.c_str()/*FIXME-UTF8*/))
1262         return false;
1263     return true;
1264 }
1265
1266 // wxVariant
1267
1268 wxVariant::wxVariant(const wxDateTime& val, const wxString& name) // Date
1269 {
1270     m_data = new wxVariantDataDateTime(val);
1271     m_name = name;
1272 }
1273
1274 bool wxVariant::operator== (const wxDateTime& value) const
1275 {
1276     wxDateTime thisValue;
1277     if (!Convert(&thisValue))
1278         return false;
1279
1280     return value.IsEqualTo(thisValue);
1281 }
1282
1283 bool wxVariant::operator!= (const wxDateTime& value) const
1284 {
1285     return (!((*this) == value));
1286 }
1287
1288 void wxVariant::operator= (const wxDateTime& value)
1289 {
1290     if (GetType() == wxT("datetime") &&
1291         m_data->GetRefCount() == 1)
1292     {
1293         ((wxVariantDataDateTime*)GetData())->SetValue(value);
1294     }
1295     else
1296     {
1297         UnRef();
1298         m_data = new wxVariantDataDateTime(value);
1299     }
1300 }
1301
1302 wxDateTime wxVariant::GetDateTime() const
1303 {
1304     wxDateTime value;
1305     if (!Convert(& value))
1306     {
1307         wxFAIL_MSG(wxT("Could not convert to a datetime"));
1308     }
1309
1310     return value;
1311 }
1312
1313 #endif // wxUSE_DATETIME
1314
1315 // ----------------------------------------------------------------------------
1316 // wxVariantDataArrayString
1317 // ----------------------------------------------------------------------------
1318
1319 class wxVariantDataArrayString: public wxVariantData
1320 {
1321 public:
1322     wxVariantDataArrayString() { }
1323     wxVariantDataArrayString(const wxArrayString& value) { m_value = value; }
1324
1325     wxArrayString GetValue() const { return m_value; }
1326     void SetValue(const wxArrayString& value) { m_value = value; }
1327
1328     virtual bool Eq(wxVariantData& data) const;
1329 #if wxUSE_STD_IOSTREAM
1330     virtual bool Write(wxSTD ostream& str) const;
1331 #endif
1332     virtual bool Write(wxString& str) const;
1333 #if wxUSE_STD_IOSTREAM
1334     virtual bool Read(wxSTD istream& str);
1335 #endif
1336     virtual bool Read(wxString& str);
1337     virtual wxString GetType() const { return wxT("arrstring"); }
1338     virtual wxVariantData* Clone() const { return new wxVariantDataArrayString(m_value); }
1339
1340 protected:
1341     wxArrayString m_value;
1342 };
1343
1344 bool wxVariantDataArrayString::Eq(wxVariantData& data) const
1345 {
1346     wxASSERT_MSG( data.GetType() == GetType(), wxT("wxVariantDataArrayString::Eq: argument mismatch") );
1347
1348     wxVariantDataArrayString& otherData = (wxVariantDataArrayString&) data;
1349
1350     return otherData.m_value == m_value;
1351 }
1352
1353 #if wxUSE_STD_IOSTREAM
1354 bool wxVariantDataArrayString::Write(wxSTD ostream& WXUNUSED(str)) const
1355 {
1356     // Not implemented
1357     return false;
1358 }
1359 #endif
1360
1361 bool wxVariantDataArrayString::Write(wxString& str) const
1362 {
1363     size_t count = m_value.GetCount();
1364     for ( size_t n = 0; n < count; n++ )
1365     {
1366         if ( n )
1367             str += _T(';');
1368
1369         str += m_value[n];
1370     }
1371
1372     return true;
1373 }
1374
1375
1376 #if wxUSE_STD_IOSTREAM
1377 bool wxVariantDataArrayString::Read(wxSTD istream& WXUNUSED(str))
1378 {
1379     // Not implemented
1380     return false;
1381 }
1382 #endif
1383
1384
1385 bool wxVariantDataArrayString::Read(wxString& str)
1386 {
1387     wxStringTokenizer tk(str, _T(";"));
1388     while ( tk.HasMoreTokens() )
1389     {
1390         m_value.Add(tk.GetNextToken());
1391     }
1392
1393     return true;
1394 }
1395
1396 // wxVariant
1397
1398 wxVariant::wxVariant(const wxArrayString& val, const wxString& name) // Strings
1399 {
1400     m_data = new wxVariantDataArrayString(val);
1401     m_name = name;
1402 }
1403
1404 bool wxVariant::operator==(const wxArrayString& WXUNUSED(value)) const
1405 {
1406     wxFAIL_MSG( _T("TODO") );
1407
1408     return false;
1409 }
1410
1411 bool wxVariant::operator!=(const wxArrayString& value) const
1412 {
1413     return !(*this == value);
1414 }
1415
1416 void wxVariant::operator=(const wxArrayString& value)
1417 {
1418     if (GetType() == wxT("arrstring") &&
1419         m_data->GetRefCount() == 1)
1420     {
1421         ((wxVariantDataArrayString *)GetData())->SetValue(value);
1422     }
1423     else
1424     {
1425         UnRef();
1426         m_data = new wxVariantDataArrayString(value);
1427     }
1428 }
1429
1430 wxArrayString wxVariant::GetArrayString() const
1431 {
1432     if ( GetType() == wxT("arrstring") )
1433         return ((wxVariantDataArrayString *)GetData())->GetValue();
1434
1435     return wxArrayString();
1436 }
1437
1438 // ----------------------------------------------------------------------------
1439 // wxVariantDataList
1440 // ----------------------------------------------------------------------------
1441
1442 class WXDLLIMPEXP_BASE wxVariantDataList: public wxVariantData
1443 {
1444 public:
1445     wxVariantDataList() {}
1446     wxVariantDataList(const wxVariantList& list);
1447     virtual ~wxVariantDataList();
1448
1449     wxVariantList& GetValue() { return m_value; }
1450     void SetValue(const wxVariantList& value) ;
1451
1452     virtual bool Eq(wxVariantData& data) const;
1453 #if wxUSE_STD_IOSTREAM
1454     virtual bool Write(wxSTD ostream& str) const;
1455 #endif
1456     virtual bool Write(wxString& str) const;
1457 #if wxUSE_STD_IOSTREAM
1458     virtual bool Read(wxSTD istream& str);
1459 #endif
1460     virtual bool Read(wxString& str);
1461     virtual wxString GetType() const { return wxT("list"); }
1462
1463     void Clear();
1464
1465     wxVariantData* Clone() const { return new wxVariantDataList(m_value); }
1466 protected:
1467     wxVariantList  m_value;
1468 };
1469
1470 wxVariantDataList::wxVariantDataList(const wxVariantList& list)
1471 {
1472     SetValue(list);
1473 }
1474
1475 wxVariantDataList::~wxVariantDataList()
1476 {
1477     Clear();
1478 }
1479
1480 void wxVariantDataList::SetValue(const wxVariantList& value)
1481 {
1482     Clear();
1483     wxVariantList::compatibility_iterator node = value.GetFirst();
1484     while (node)
1485     {
1486         wxVariant* var = node->GetData();
1487         m_value.Append(new wxVariant(*var));
1488         node = node->GetNext();
1489     }
1490 }
1491
1492 void wxVariantDataList::Clear()
1493 {
1494     wxVariantList::compatibility_iterator node = m_value.GetFirst();
1495     while (node)
1496     {
1497         wxVariant* var = node->GetData();
1498         delete var;
1499         node = node->GetNext();
1500     }
1501     m_value.Clear();
1502 }
1503
1504 bool wxVariantDataList::Eq(wxVariantData& data) const
1505 {
1506     wxASSERT_MSG( (data.GetType() == wxT("list")), wxT("wxVariantDataList::Eq: argument mismatch") );
1507
1508     wxVariantDataList& listData = (wxVariantDataList&) data;
1509     wxVariantList::compatibility_iterator node1 = m_value.GetFirst();
1510     wxVariantList::compatibility_iterator node2 = listData.GetValue().GetFirst();
1511     while (node1 && node2)
1512     {
1513         wxVariant* var1 = node1->GetData();
1514         wxVariant* var2 = node2->GetData();
1515         if ((*var1) != (*var2))
1516             return false;
1517         node1 = node1->GetNext();
1518         node2 = node2->GetNext();
1519     }
1520     if (node1 || node2) return false;
1521     return true;
1522 }
1523
1524 #if wxUSE_STD_IOSTREAM
1525 bool wxVariantDataList::Write(wxSTD ostream& str) const
1526 {
1527     wxString s;
1528     Write(s);
1529     str << (const char*) s.mb_str();
1530     return true;
1531 }
1532 #endif
1533
1534 bool wxVariantDataList::Write(wxString& str) const
1535 {
1536     str = wxEmptyString;
1537     wxVariantList::compatibility_iterator node = m_value.GetFirst();
1538     while (node)
1539     {
1540         wxVariant* var = node->GetData();
1541         if (node != m_value.GetFirst())
1542           str += wxT(" ");
1543         wxString str1;
1544         str += var->MakeString();
1545         node = node->GetNext();
1546     }
1547
1548     return true;
1549 }
1550
1551 #if wxUSE_STD_IOSTREAM
1552 bool wxVariantDataList::Read(wxSTD istream& WXUNUSED(str))
1553 {
1554     wxFAIL_MSG(wxT("Unimplemented"));
1555     // TODO
1556     return false;
1557 }
1558 #endif
1559
1560 bool wxVariantDataList::Read(wxString& WXUNUSED(str))
1561 {
1562     wxFAIL_MSG(wxT("Unimplemented"));
1563     // TODO
1564     return false;
1565 }
1566
1567 // wxVariant
1568
1569 wxVariant::wxVariant(const wxVariantList& val, const wxString& name) // List of variants
1570 {
1571     m_data = new wxVariantDataList(val);
1572     m_name = name;
1573 }
1574
1575 bool wxVariant::operator== (const wxVariantList& value) const
1576 {
1577     wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for == operator") );
1578
1579     wxVariantDataList other(value);
1580     return (GetData()->Eq(other));
1581 }
1582
1583 bool wxVariant::operator!= (const wxVariantList& value) const
1584 {
1585     return (!((*this) == value));
1586 }
1587
1588 void wxVariant::operator= (const wxVariantList& value)
1589 {
1590     if (GetType() == wxT("list") &&
1591         m_data->GetRefCount() == 1)
1592     {
1593         ((wxVariantDataList*)GetData())->SetValue(value);
1594     }
1595     else
1596     {
1597         UnRef();
1598         m_data = new wxVariantDataList(value);
1599     }
1600 }
1601
1602 wxVariantList& wxVariant::GetList() const
1603 {
1604     wxASSERT( (GetType() == wxT("list")) );
1605
1606     return (wxVariantList&) ((wxVariantDataList*) m_data)->GetValue();
1607 }
1608
1609 // Make empty list
1610 void wxVariant::NullList()
1611 {
1612     SetData(new wxVariantDataList());
1613 }
1614
1615 // Append to list
1616 void wxVariant::Append(const wxVariant& value)
1617 {
1618     wxVariantList& list = GetList();
1619
1620     list.Append(new wxVariant(value));
1621 }
1622
1623 // Insert at front of list
1624 void wxVariant::Insert(const wxVariant& value)
1625 {
1626     wxVariantList& list = GetList();
1627
1628     list.Insert(new wxVariant(value));
1629 }
1630
1631 // Returns true if the variant is a member of the list
1632 bool wxVariant::Member(const wxVariant& value) const
1633 {
1634     wxVariantList& list = GetList();
1635
1636     wxVariantList::compatibility_iterator node = list.GetFirst();
1637     while (node)
1638     {
1639         wxVariant* other = node->GetData();
1640         if (value == *other)
1641             return true;
1642         node = node->GetNext();
1643     }
1644     return false;
1645 }
1646
1647 // Deletes the nth element of the list
1648 bool wxVariant::Delete(size_t item)
1649 {
1650     wxVariantList& list = GetList();
1651
1652     wxASSERT_MSG( (item < list.GetCount()), wxT("Invalid index to Delete") );
1653     wxVariantList::compatibility_iterator node = list.Item(item);
1654     wxVariant* variant = node->GetData();
1655     delete variant;
1656     list.Erase(node);
1657     return true;
1658 }
1659
1660 // Clear list
1661 void wxVariant::ClearList()
1662 {
1663     if (!IsNull() && (GetType() == wxT("list")))
1664     {
1665         ((wxVariantDataList*) m_data)->Clear();
1666     }
1667     else
1668     {
1669         if (!GetType().IsSameAs(wxT("list")))
1670             UnRef();
1671
1672         m_data = new wxVariantDataList;
1673     }
1674 }
1675
1676 // Treat a list variant as an array
1677 wxVariant wxVariant::operator[] (size_t idx) const
1678 {
1679     wxASSERT_MSG( GetType() == wxT("list"), wxT("Invalid type for array operator") );
1680
1681     if (GetType() == wxT("list"))
1682     {
1683         wxVariantDataList* data = (wxVariantDataList*) m_data;
1684         wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
1685         return *(data->GetValue().Item(idx)->GetData());
1686     }
1687     return wxNullVariant;
1688 }
1689
1690 wxVariant& wxVariant::operator[] (size_t idx)
1691 {
1692     // We can't return a reference to a variant for a string list, since the string
1693     // is actually stored as a char*, not a variant.
1694
1695     wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for array operator") );
1696
1697     wxVariantDataList* data = (wxVariantDataList*) m_data;
1698     wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
1699
1700     return * (data->GetValue().Item(idx)->GetData());
1701 }
1702
1703 // Return the number of elements in a list
1704 size_t wxVariant::GetCount() const
1705 {
1706     wxASSERT_MSG( GetType() == wxT("list"), wxT("Invalid type for GetCount()") );
1707
1708     if (GetType() == wxT("list"))
1709     {
1710         wxVariantDataList* data = (wxVariantDataList*) m_data;
1711         return data->GetValue().GetCount();
1712     }
1713     return 0;
1714 }
1715
1716 // ----------------------------------------------------------------------------
1717 // Type conversion
1718 // ----------------------------------------------------------------------------
1719
1720 bool wxVariant::Convert(long* value) const
1721 {
1722     wxString type(GetType());
1723     if (type == wxT("double"))
1724         *value = (long) (((wxVariantDoubleData*)GetData())->GetValue());
1725     else if (type == wxT("long"))
1726         *value = ((wxVariantDataLong*)GetData())->GetValue();
1727     else if (type == wxT("bool"))
1728         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
1729     else if (type == wxT("string"))
1730         *value = wxAtol(((wxVariantDataString*)GetData())->GetValue());
1731     else
1732         return false;
1733
1734     return true;
1735 }
1736
1737 bool wxVariant::Convert(bool* value) const
1738 {
1739     wxString type(GetType());
1740     if (type == wxT("double"))
1741         *value = ((int) (((wxVariantDoubleData*)GetData())->GetValue()) != 0);
1742     else if (type == wxT("long"))
1743         *value = (((wxVariantDataLong*)GetData())->GetValue() != 0);
1744     else if (type == wxT("bool"))
1745         *value = ((wxVariantDataBool*)GetData())->GetValue();
1746     else if (type == wxT("string"))
1747     {
1748         wxString val(((wxVariantDataString*)GetData())->GetValue());
1749         val.MakeLower();
1750         if (val == wxT("true") || val == wxT("yes") || val == wxT('1') )
1751             *value = true;
1752         else if (val == wxT("false") || val == wxT("no") || val == wxT('0') )
1753             *value = false;
1754         else
1755             return false;
1756     }
1757     else
1758         return false;
1759
1760     return true;
1761 }
1762
1763 bool wxVariant::Convert(double* value) const
1764 {
1765     wxString type(GetType());
1766     if (type == wxT("double"))
1767         *value = ((wxVariantDoubleData*)GetData())->GetValue();
1768     else if (type == wxT("long"))
1769         *value = (double) (((wxVariantDataLong*)GetData())->GetValue());
1770     else if (type == wxT("bool"))
1771         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
1772     else if (type == wxT("string"))
1773         *value = (double) wxAtof(((wxVariantDataString*)GetData())->GetValue());
1774     else
1775         return false;
1776
1777     return true;
1778 }
1779
1780 bool wxVariant::Convert(wxUniChar* value) const
1781 {
1782     wxString type(GetType());
1783     if (type == wxT("char"))
1784         *value = ((wxVariantDataChar*)GetData())->GetValue();
1785     else if (type == wxT("long"))
1786         *value = (char) (((wxVariantDataLong*)GetData())->GetValue());
1787     else if (type == wxT("bool"))
1788         *value = (char) (((wxVariantDataBool*)GetData())->GetValue());
1789     else
1790         return false;
1791
1792     return true;
1793 }
1794
1795 bool wxVariant::Convert(char* value) const
1796 {
1797     wxUniChar ch;
1798     if ( !Convert(&ch) )
1799         return false;
1800     *value = ch;
1801     return true;
1802 }
1803
1804 bool wxVariant::Convert(wchar_t* value) const
1805 {
1806     wxUniChar ch;
1807     if ( !Convert(&ch) )
1808         return false;
1809     *value = ch;
1810     return true;
1811 }
1812
1813 bool wxVariant::Convert(wxString* value) const
1814 {
1815     *value = MakeString();
1816     return true;
1817 }
1818
1819 #if wxUSE_DATETIME
1820 bool wxVariant::Convert(wxDateTime* value) const
1821 {
1822     wxString type(GetType());
1823     if (type == wxT("datetime"))
1824     {
1825         *value = ((wxVariantDataDateTime*)GetData())->GetValue();
1826         return true;
1827     }
1828     // Fallback to string conversion
1829     wxString val;
1830     return Convert(&val) &&
1831                 (value->ParseDateTime(val.c_str()/*FIXME-UTF8*/) ||
1832                  value->ParseDate(val.c_str()/*FIXME-UTF8*/) ||
1833                  value->ParseTime(val.c_str()/*FIXME-UTF8*/));
1834 }
1835 #endif // wxUSE_DATETIME
1836
1837 #endif // wxUSE_VARIANT