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