src/common/variant.cpp

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