src/common/variant.cpp

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