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