1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxVariant class, container for any type
4 // Author: Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "variant.h"
14 #pragma implementation "time.h"
15 #pragma implementation "date.h"
18 // For compilers that support precompilation, includes "wx/wx.h".
19 #include "wx/wxprec.h"
25 #if wxUSE_STD_IOSTREAM
34 #include "wx/stream.h"
35 #include "wx/txtstrm.h"
38 #include "wx/string.h"
39 #include "wx/tokenzr.h"
41 #include "wx/variant.h"
44 IMPLEMENT_DYNAMIC_CLASS(wxDate
, wxObject
)
45 IMPLEMENT_DYNAMIC_CLASS(wxTime
, wxObject
)
47 wxTime::tFormat
wxTime::ms_Format
= wxTime::wx12h
;
48 wxTime::tPrecision
wxTime::ms_Precision
= wxTime::wxStdMinSec
;
49 wxChar
wxTime::ms_bufTime
[128];
52 IMPLEMENT_ABSTRACT_CLASS(wxVariantData
, wxObject
)
54 wxVariant WXDLLEXPORT wxNullVariant
;
60 class WXDLLEXPORT wxVariantDataList
: public wxVariantData
62 DECLARE_DYNAMIC_CLASS(wxVariantDataList
)
64 wxVariantDataList() {}
65 wxVariantDataList(const wxList
& list
);
68 wxList
& GetValue() const { return (wxList
&) m_value
; }
69 void SetValue(const wxList
& value
) ;
71 virtual void Copy(wxVariantData
& data
);
72 virtual bool Eq(wxVariantData
& data
) const;
73 #if wxUSE_STD_IOSTREAM
74 virtual bool Write(wxSTD ostream
& str
) const;
76 virtual bool Write(wxString
& str
) const;
77 #if wxUSE_STD_IOSTREAM
78 virtual bool Read(wxSTD istream
& str
);
80 virtual bool Read(wxString
& str
);
81 virtual wxString
GetType() const { return wxT("list"); };
89 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataList
, wxVariantData
)
91 wxVariantDataList::wxVariantDataList(const wxList
& list
)
96 wxVariantDataList::~wxVariantDataList()
101 void wxVariantDataList::SetValue(const wxList
& value
)
104 wxNode
* node
= value
.First();
107 wxVariant
* var
= (wxVariant
*) node
->Data();
108 m_value
.Append(new wxVariant(*var
));
113 void wxVariantDataList::Clear()
115 wxNode
* node
= m_value
.First();
118 wxVariant
* var
= (wxVariant
*) node
->Data();
125 void wxVariantDataList::Copy(wxVariantData
& data
)
127 wxASSERT_MSG( (data
.GetType() == wxT("list")), wxT("wxVariantDataList::Copy: Can't copy to this type of data") );
129 wxVariantDataList
& listData
= (wxVariantDataList
&) data
;
132 wxNode
* node
= m_value
.First();
135 wxVariant
* var
= (wxVariant
*) node
->Data();
136 listData
.m_value
.Append(new wxVariant(*var
));
141 bool wxVariantDataList::Eq(wxVariantData
& data
) const
143 wxASSERT_MSG( (data
.GetType() == wxT("list")), wxT("wxVariantDataList::Eq: argument mismatch") );
145 wxVariantDataList
& listData
= (wxVariantDataList
&) data
;
146 wxNode
* node1
= m_value
.First();
147 wxNode
* node2
= listData
.GetValue().First();
148 while (node1
&& node2
)
150 wxVariant
* var1
= (wxVariant
*) node1
->Data();
151 wxVariant
* var2
= (wxVariant
*) node2
->Data();
152 if ((*var1
) != (*var2
))
154 node1
= node1
->Next();
155 node2
= node2
->Next();
157 if (node1
|| node2
) return FALSE
;
161 #if wxUSE_STD_IOSTREAM
162 bool wxVariantDataList::Write(wxSTD ostream
& str
) const
166 str
<< (const char*) s
.mb_str();
171 bool wxVariantDataList::Write(wxString
& str
) const
174 wxNode
* node
= m_value
.First();
177 wxVariant
* var
= (wxVariant
*) node
->Data();
178 if (node
!= m_value
.First())
181 str
+= var
->MakeString();
188 #if wxUSE_STD_IOSTREAM
189 bool wxVariantDataList::Read(wxSTD istream
& WXUNUSED(str
))
191 wxFAIL_MSG(wxT("Unimplemented"));
197 bool wxVariantDataList::Read(wxString
& WXUNUSED(str
))
199 wxFAIL_MSG(wxT("Unimplemented"));
205 * wxVariantDataStringList
208 class WXDLLEXPORT wxVariantDataStringList
: public wxVariantData
210 DECLARE_DYNAMIC_CLASS(wxVariantDataStringList
)
212 wxVariantDataStringList() {}
213 wxVariantDataStringList(const wxStringList
& list
) { m_value
= list
; }
215 wxStringList
& GetValue() const { return (wxStringList
&) m_value
; }
216 void SetValue(const wxStringList
& value
);
218 virtual void Copy(wxVariantData
& data
);
219 virtual bool Eq(wxVariantData
& data
) const;
220 #if wxUSE_STD_IOSTREAM
221 virtual bool Write(wxSTD ostream
& str
) const;
223 virtual bool Write(wxString
& str
) const;
224 #if wxUSE_STD_IOSTREAM
225 virtual bool Read(wxSTD istream
& str
);
227 virtual bool Read(wxString
& str
);
228 virtual wxString
GetType() const { return wxT("stringlist"); };
231 wxStringList m_value
;
234 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataStringList
, wxVariantData
)
236 void wxVariantDataStringList::SetValue(const wxStringList
& value
)
241 void wxVariantDataStringList::Copy(wxVariantData
& data
)
243 wxASSERT_MSG( (data
.GetType() == wxT("stringlist")), wxT("wxVariantDataStringList::Copy: Can't copy to this type of data") );
245 wxVariantDataStringList
& listData
= (wxVariantDataStringList
&) data
;
247 listData
.m_value
= m_value
;
250 bool wxVariantDataStringList::Eq(wxVariantData
& data
) const
252 wxASSERT_MSG( (data
.GetType() == wxT("stringlist")), wxT("wxVariantDataStringList::Eq: argument mismatch") );
254 wxVariantDataStringList
& listData
= (wxVariantDataStringList
&) data
;
255 wxNode
* node1
= m_value
.First();
256 wxNode
* node2
= listData
.GetValue().First();
257 while (node1
&& node2
)
259 wxString
str1 ((wxChar
*) node1
->Data());
260 wxString
str2 ((wxChar
*) node2
->Data());
263 node1
= node1
->Next();
264 node2
= node2
->Next();
266 if (node1
|| node2
) return FALSE
;
270 #if wxUSE_STD_IOSTREAM
271 bool wxVariantDataStringList::Write(wxSTD ostream
& str
) const
275 str
<< (const char*) s
.mb_str();
280 bool wxVariantDataStringList::Write(wxString
& str
) const
283 wxNode
* node
= m_value
.First();
286 wxChar
* s
= (wxChar
*) node
->Data();
287 if (node
!= m_value
.First())
296 #if wxUSE_STD_IOSTREAM
297 bool wxVariantDataStringList::Read(wxSTD istream
& WXUNUSED(str
))
299 wxFAIL_MSG(wxT("Unimplemented"));
305 bool wxVariantDataStringList::Read(wxString
& WXUNUSED(str
))
307 wxFAIL_MSG(wxT("Unimplemented"));
316 class WXDLLEXPORT wxVariantDataLong
: public wxVariantData
318 DECLARE_DYNAMIC_CLASS(wxVariantDataLong
)
320 wxVariantDataLong() { m_value
= 0; }
321 wxVariantDataLong(long value
) { m_value
= value
; }
323 inline long GetValue() const { return m_value
; }
324 inline void SetValue(long value
) { m_value
= value
; }
326 virtual void Copy(wxVariantData
& data
);
327 virtual bool Eq(wxVariantData
& data
) const;
329 virtual bool Read(wxString
& str
);
330 virtual bool Write(wxString
& str
) const;
331 #if wxUSE_STD_IOSTREAM
332 virtual bool Read(wxSTD istream
& str
);
333 virtual bool Write(wxSTD ostream
& str
) const;
336 virtual bool Read(wxInputStream
& str
);
337 virtual bool Write(wxOutputStream
&str
) const;
338 #endif // wxUSE_STREAMS
340 virtual wxString
GetType() const { return wxT("long"); };
346 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataLong
, wxVariantData
)
348 void wxVariantDataLong::Copy(wxVariantData
& data
)
350 wxASSERT_MSG( (data
.GetType() == wxT("long")), wxT("wxVariantDataLong::Copy: Can't copy to this type of data") );
352 wxVariantDataLong
& otherData
= (wxVariantDataLong
&) data
;
354 otherData
.m_value
= m_value
;
357 bool wxVariantDataLong::Eq(wxVariantData
& data
) const
359 wxASSERT_MSG( (data
.GetType() == wxT("long")), wxT("wxVariantDataLong::Eq: argument mismatch") );
361 wxVariantDataLong
& otherData
= (wxVariantDataLong
&) data
;
363 return (otherData
.m_value
== m_value
);
366 #if wxUSE_STD_IOSTREAM
367 bool wxVariantDataLong::Write(wxSTD ostream
& str
) const
371 str
<< (const char*) s
.mb_str();
376 bool wxVariantDataLong::Write(wxString
& str
) const
378 str
.Printf(wxT("%ld"), m_value
);
382 #if wxUSE_STD_IOSTREAM
383 bool wxVariantDataLong::Read(wxSTD istream
& str
)
391 bool wxVariantDataLong::Write(wxOutputStream
& str
) const
393 wxTextOutputStream
s(str
);
395 s
.Write32((size_t)m_value
);
399 bool wxVariantDataLong::Read(wxInputStream
& str
)
401 wxTextInputStream
s(str
);
402 m_value
= s
.Read32();
405 #endif // wxUSE_STREAMS
407 bool wxVariantDataLong::Read(wxString
& str
)
409 m_value
= wxAtol((const wxChar
*) str
);
417 class WXDLLEXPORT wxVariantDataReal
: public wxVariantData
419 DECLARE_DYNAMIC_CLASS(wxVariantDataReal
)
421 wxVariantDataReal() { m_value
= 0.0; }
422 wxVariantDataReal(double value
) { m_value
= value
; }
424 inline double GetValue() const { return m_value
; }
425 inline void SetValue(double value
) { m_value
= value
; }
427 virtual void Copy(wxVariantData
& data
);
428 virtual bool Eq(wxVariantData
& data
) const;
429 virtual bool Read(wxString
& str
);
430 #if wxUSE_STD_IOSTREAM
431 virtual bool Write(wxSTD ostream
& str
) const;
433 virtual bool Write(wxString
& str
) const;
434 #if wxUSE_STD_IOSTREAM
435 virtual bool Read(wxSTD istream
& str
);
438 virtual bool Read(wxInputStream
& str
);
439 virtual bool Write(wxOutputStream
&str
) const;
440 #endif // wxUSE_STREAMS
441 virtual wxString
GetType() const { return wxT("double"); };
447 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataReal
, wxVariantData
)
449 void wxVariantDataReal::Copy(wxVariantData
& data
)
451 wxASSERT_MSG( (data
.GetType() == wxT("double")), wxT("wxVariantDataReal::Copy: Can't copy to this type of data") );
453 wxVariantDataReal
& otherData
= (wxVariantDataReal
&) data
;
455 otherData
.m_value
= m_value
;
458 bool wxVariantDataReal::Eq(wxVariantData
& data
) const
460 wxASSERT_MSG( (data
.GetType() == wxT("double")), wxT("wxVariantDataReal::Eq: argument mismatch") );
462 wxVariantDataReal
& otherData
= (wxVariantDataReal
&) data
;
464 return (otherData
.m_value
== m_value
);
467 #if wxUSE_STD_IOSTREAM
468 bool wxVariantDataReal::Write(wxSTD ostream
& str
) const
472 str
<< (const char*) s
.mb_str();
477 bool wxVariantDataReal::Write(wxString
& str
) const
479 str
.Printf(wxT("%.4f"), m_value
);
483 #if wxUSE_STD_IOSTREAM
484 bool wxVariantDataReal::Read(wxSTD istream
& str
)
492 bool wxVariantDataReal::Write(wxOutputStream
& str
) const
494 wxTextOutputStream
s(str
);
495 s
.WriteDouble((double)m_value
);
499 bool wxVariantDataReal::Read(wxInputStream
& str
)
501 wxTextInputStream
s(str
);
502 m_value
= (float)s
.ReadDouble();
505 #endif // wxUSE_STREAMS
507 bool wxVariantDataReal::Read(wxString
& str
)
509 m_value
= wxAtof((const wxChar
*) str
);
518 class WXDLLEXPORT wxVariantDataBool
: public wxVariantData
520 DECLARE_DYNAMIC_CLASS(wxVariantDataBool
)
522 wxVariantDataBool() { m_value
= 0; }
523 wxVariantDataBool(bool value
) { m_value
= value
; }
525 inline bool GetValue() const { return m_value
; }
526 inline void SetValue(bool value
) { m_value
= value
; }
528 virtual void Copy(wxVariantData
& data
);
529 virtual bool Eq(wxVariantData
& data
) const;
530 #if wxUSE_STD_IOSTREAM
531 virtual bool Write(wxSTD ostream
& str
) const;
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
);
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"); };
548 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataBool
, wxVariantData
)
550 void wxVariantDataBool::Copy(wxVariantData
& data
)
552 wxASSERT_MSG( (data
.GetType() == wxT("bool")), wxT("wxVariantDataBool::Copy: Can't copy to this type of data") );
554 wxVariantDataBool
& otherData
= (wxVariantDataBool
&) data
;
556 otherData
.m_value
= m_value
;
559 bool wxVariantDataBool::Eq(wxVariantData
& data
) const
561 wxASSERT_MSG( (data
.GetType() == wxT("bool")), wxT("wxVariantDataBool::Eq: argument mismatch") );
563 wxVariantDataBool
& otherData
= (wxVariantDataBool
&) data
;
565 return (otherData
.m_value
== m_value
);
568 #if wxUSE_STD_IOSTREAM
569 bool wxVariantDataBool::Write(wxSTD ostream
& str
) const
573 str
<< (const char*) s
.mb_str();
578 bool wxVariantDataBool::Write(wxString
& str
) const
580 str
.Printf(wxT("%d"), (int) m_value
);
584 #if wxUSE_STD_IOSTREAM
585 bool wxVariantDataBool::Read(wxSTD istream
& WXUNUSED(str
))
587 wxFAIL_MSG(wxT("Unimplemented"));
588 // str >> (long) m_value;
594 bool wxVariantDataBool::Write(wxOutputStream
& str
) const
596 wxTextOutputStream
s(str
);
602 bool wxVariantDataBool::Read(wxInputStream
& str
)
604 wxTextInputStream
s(str
);
606 m_value
= s
.Read8() != 0;
609 #endif // wxUSE_STREAMS
611 bool wxVariantDataBool::Read(wxString
& str
)
613 m_value
= (wxAtol((const wxChar
*) str
) != 0);
622 class WXDLLEXPORT wxVariantDataChar
: public wxVariantData
624 DECLARE_DYNAMIC_CLASS(wxVariantDataChar
)
626 wxVariantDataChar() { m_value
= 0; }
627 wxVariantDataChar(char value
) { m_value
= value
; }
629 inline char GetValue() const { return m_value
; }
630 inline void SetValue(char value
) { m_value
= value
; }
632 virtual void Copy(wxVariantData
& data
);
633 virtual bool Eq(wxVariantData
& data
) const;
634 #if wxUSE_STD_IOSTREAM
635 virtual bool Read(wxSTD istream
& str
);
636 virtual bool Write(wxSTD ostream
& str
) const;
638 virtual bool Read(wxString
& str
);
639 virtual bool Write(wxString
& str
) const;
641 virtual bool Read(wxInputStream
& str
);
642 virtual bool Write(wxOutputStream
& str
) const;
643 #endif // wxUSE_STREAMS
644 virtual wxString
GetType() const { return wxT("char"); };
650 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataChar
, wxVariantData
)
652 void wxVariantDataChar::Copy(wxVariantData
& data
)
654 wxASSERT_MSG( (data
.GetType() == wxT("char")), wxT("wxVariantDataChar::Copy: Can't copy to this type of data") );
656 wxVariantDataChar
& otherData
= (wxVariantDataChar
&) data
;
658 otherData
.m_value
= m_value
;
661 bool wxVariantDataChar::Eq(wxVariantData
& data
) const
663 wxASSERT_MSG( (data
.GetType() == wxT("char")), wxT("wxVariantDataChar::Eq: argument mismatch") );
665 wxVariantDataChar
& otherData
= (wxVariantDataChar
&) data
;
667 return (otherData
.m_value
== m_value
);
670 #if wxUSE_STD_IOSTREAM
671 bool wxVariantDataChar::Write(wxSTD ostream
& str
) const
675 str
<< (const char*) s
.mb_str();
680 bool wxVariantDataChar::Write(wxString
& str
) const
682 str
.Printf(wxT("%c"), m_value
);
686 #if wxUSE_STD_IOSTREAM
687 bool wxVariantDataChar::Read(wxSTD istream
& WXUNUSED(str
))
689 wxFAIL_MSG(wxT("Unimplemented"));
696 bool wxVariantDataChar::Write(wxOutputStream
& str
) const
698 wxTextOutputStream
s(str
);
704 bool wxVariantDataChar::Read(wxInputStream
& str
)
706 wxTextInputStream
s(str
);
711 #endif // wxUSE_STREAMS
713 bool wxVariantDataChar::Read(wxString
& str
)
715 m_value
= str
[(size_t)0];
720 * wxVariantDataString
723 #if defined(__BORLANDC__) && defined(__WIN16__)
724 // Change name because of truncation
725 #define wxVariantDataString wxVariantStringData
728 class WXDLLEXPORT wxVariantDataString
: public wxVariantData
730 #if defined(__BORLANDC__) && defined(__WIN16__)
731 DECLARE_DYNAMIC_CLASS(wxVariantStringData
)
733 DECLARE_DYNAMIC_CLASS(wxVariantDataString
)
736 wxVariantDataString() { }
737 wxVariantDataString(const wxString
& value
) { m_value
= value
; }
739 inline wxString
GetValue() const { return m_value
; }
740 inline void SetValue(const wxString
& value
) { m_value
= value
; }
742 virtual void Copy(wxVariantData
& data
);
743 virtual bool Eq(wxVariantData
& data
) const;
744 #if wxUSE_STD_IOSTREAM
745 virtual bool Write(wxSTD ostream
& str
) const;
747 virtual bool Read(wxString
& str
);
748 virtual bool Write(wxString
& str
) const;
749 #if wxUSE_STD_IOSTREAM
750 virtual bool Read(wxSTD istream
& str
);
753 virtual bool Read(wxInputStream
& str
);
754 virtual bool Write(wxOutputStream
& str
) const;
755 #endif // wxUSE_STREAMS
756 virtual wxString
GetType() const { return wxT("string"); };
762 void wxVariantDataString::Copy(wxVariantData
& data
)
764 wxASSERT_MSG( (data
.GetType() == wxT("string")), wxT("wxVariantDataString::Copy: Can't copy to this type of data") );
766 wxVariantDataString
& otherData
= (wxVariantDataString
&) data
;
768 otherData
.m_value
= m_value
;
771 bool wxVariantDataString::Eq(wxVariantData
& data
) const
773 wxASSERT_MSG( (data
.GetType() == wxT("string")), wxT("wxVariantDataString::Eq: argument mismatch") );
775 wxVariantDataString
& otherData
= (wxVariantDataString
&) data
;
777 return (otherData
.m_value
== m_value
);
780 #if wxUSE_STD_IOSTREAM
781 bool wxVariantDataString::Write(wxSTD ostream
& str
) const
783 str
<< (const char*) m_value
.mb_str();
788 bool wxVariantDataString::Write(wxString
& str
) const
794 #if wxUSE_STD_IOSTREAM
795 bool wxVariantDataString::Read(wxSTD istream
& str
)
803 bool wxVariantDataString::Write(wxOutputStream
& str
) const
805 // why doesn't wxOutputStream::operator<< take "const wxString&"
806 wxTextOutputStream
s(str
);
807 s
.WriteString(m_value
);
811 bool wxVariantDataString::Read(wxInputStream
& str
)
813 wxTextInputStream
s(str
);
815 m_value
= s
.ReadString();
818 #endif // wxUSE_STREAMS
820 bool wxVariantDataString::Read(wxString
& str
)
826 #if defined(__BORLANDC__) && defined(__WIN16__)
827 IMPLEMENT_DYNAMIC_CLASS(wxVariantStringData
, wxVariantData
)
829 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString
, wxVariantData
)
836 // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
837 #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
839 class wxVariantDataTime
: public wxVariantData
841 DECLARE_DYNAMIC_CLASS(wxVariantDataTime
)
843 wxVariantDataTime() { }
844 wxVariantDataTime(const wxTime
& value
) { m_value
= value
; }
846 inline wxTime
GetValue() const { return m_value
; }
847 inline void SetValue(const wxTime
& value
) { m_value
= value
; }
849 virtual void Copy(wxVariantData
& data
);
850 virtual bool Eq(wxVariantData
& data
) const;
851 #if wxUSE_STD_IOSTREAM
852 virtual bool Write(wxSTD ostream
& str
) const;
854 virtual bool Write(wxString
& str
) const;
855 #if wxUSE_STD_IOSTREAM
856 virtual bool Read(wxSTD istream
& str
);
858 virtual bool Read(wxString
& str
);
859 virtual wxString
GetType() const { return wxT("time"); };
860 virtual wxVariantData
* Clone() { return new wxVariantDataTime
; }
866 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataTime
, wxVariantData
)
868 void wxVariantDataTime::Copy(wxVariantData
& data
)
870 wxASSERT_MSG( (data
.GetType() == wxT("time")), wxT("wxVariantDataTime::Copy: Can't copy to this type of data") );
872 wxVariantDataTime
& otherData
= (wxVariantDataTime
&) data
;
874 otherData
.m_value
= m_value
;
877 bool wxVariantDataTime::Eq(wxVariantData
& data
) const
879 wxASSERT_MSG( (data
.GetType() == wxT("time")), wxT("wxVariantDataTime::Eq: argument mismatch") );
881 wxVariantDataTime
& otherData
= (wxVariantDataTime
&) data
;
883 return (otherData
.m_value
== m_value
);
886 #if wxUSE_STD_IOSTREAM
887 bool wxVariantDataTime::Write(wxSTD ostream
& str
) const
891 str
<< (const char*) s
.mb_str();
896 bool wxVariantDataTime::Write(wxString
& str
) const
898 wxChar
*s
= m_value
.FormatTime();
903 #if wxUSE_STD_IOSTREAM
904 bool wxVariantDataTime::Read(wxSTD istream
& WXUNUSED(str
))
911 bool wxVariantDataTime::Read(wxString
& WXUNUSED(str
))
921 class wxVariantDataDate
: public wxVariantData
923 DECLARE_DYNAMIC_CLASS(wxVariantDataDate
)
925 wxVariantDataDate() { }
926 wxVariantDataDate(const wxDate
& value
) { m_value
= value
; }
928 inline wxDate
GetValue() const { return m_value
; }
929 inline void SetValue(const wxDate
& value
) { m_value
= value
; }
931 virtual void Copy(wxVariantData
& data
);
932 virtual bool Eq(wxVariantData
& data
) const;
933 #if wxUSE_STD_IOSTREAM
934 virtual bool Write(wxSTD ostream
& str
) const;
936 virtual bool Write(wxString
& str
) const;
937 #if wxUSE_STD_IOSTREAM
938 virtual bool Read(wxSTD istream
& str
);
940 virtual bool Read(wxString
& str
);
941 virtual wxString
GetType() const { return wxT("date"); };
942 virtual wxVariantData
* Clone() { return new wxVariantDataDate
; }
948 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDate
, wxVariantData
)
950 void wxVariantDataDate::Copy(wxVariantData
& data
)
952 wxASSERT_MSG( (data
.GetType() == wxT("date")), wxT("wxVariantDataDate::Copy: Can't copy to this type of data") );
954 wxVariantDataDate
& otherData
= (wxVariantDataDate
&) data
;
956 otherData
.m_value
= m_value
;
959 bool wxVariantDataDate::Eq(wxVariantData
& data
) const
961 wxASSERT_MSG( (data
.GetType() == wxT("date")), wxT("wxVariantDataDate::Eq: argument mismatch") );
963 wxVariantDataDate
& otherData
= (wxVariantDataDate
&) data
;
965 return (otherData
.m_value
== m_value
);
968 #if wxUSE_STD_IOSTREAM
969 bool wxVariantDataDate::Write(wxSTD ostream
& str
) const
973 str
<< (const char*) s
.mb_str();
978 bool wxVariantDataDate::Write(wxString
& str
) const
980 str
= m_value
.FormatDate();
984 #if wxUSE_STD_IOSTREAM
985 bool wxVariantDataDate::Read(wxSTD istream
& WXUNUSED(str
))
992 bool wxVariantDataDate::Read(wxString
& WXUNUSED(str
))
1001 * wxVariantDataVoidPtr
1004 class wxVariantDataVoidPtr
: public wxVariantData
1006 DECLARE_DYNAMIC_CLASS(wxVariantDataVoidPtr
)
1008 wxVariantDataVoidPtr() { }
1009 wxVariantDataVoidPtr(void* value
) { m_value
= value
; }
1011 inline void* GetValue() const { return m_value
; }
1012 inline void SetValue(void* value
) { m_value
= value
; }
1014 virtual void Copy(wxVariantData
& data
);
1015 virtual bool Eq(wxVariantData
& data
) const;
1016 #if wxUSE_STD_IOSTREAM
1017 virtual bool Write(wxSTD ostream
& str
) const;
1019 virtual bool Write(wxString
& str
) const;
1020 #if wxUSE_STD_IOSTREAM
1021 virtual bool Read(wxSTD istream
& str
);
1023 virtual bool Read(wxString
& str
);
1024 virtual wxString
GetType() const { return wxT("void*"); };
1025 virtual wxVariantData
* Clone() { return new wxVariantDataVoidPtr
; }
1030 DECLARE_NO_COPY_CLASS(wxVariantDataVoidPtr
)
1033 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr
, wxVariantData
)
1035 void wxVariantDataVoidPtr::Copy(wxVariantData
& data
)
1037 wxASSERT_MSG( (data
.GetType() == wxT("void*")), wxT("wxVariantDataVoidPtr::Copy: Can't copy to this type of data") );
1039 wxVariantDataVoidPtr
& otherData
= (wxVariantDataVoidPtr
&) data
;
1041 otherData
.m_value
= m_value
;
1044 bool wxVariantDataVoidPtr::Eq(wxVariantData
& data
) const
1046 wxASSERT_MSG( (data
.GetType() == wxT("void*")), wxT("wxVariantDataVoidPtr::Eq: argument mismatch") );
1048 wxVariantDataVoidPtr
& otherData
= (wxVariantDataVoidPtr
&) data
;
1050 return (otherData
.m_value
== m_value
);
1053 #if wxUSE_STD_IOSTREAM
1054 bool wxVariantDataVoidPtr::Write(wxSTD ostream
& str
) const
1058 str
<< (const char*) s
.mb_str();
1063 bool wxVariantDataVoidPtr::Write(wxString
& str
) const
1065 str
.Printf(wxT("%ld"), (long) m_value
);
1069 #if wxUSE_STD_IOSTREAM
1070 bool wxVariantDataVoidPtr::Read(wxSTD istream
& WXUNUSED(str
))
1077 bool wxVariantDataVoidPtr::Read(wxString
& WXUNUSED(str
))
1084 * wxVariantDataDateTime
1087 class wxVariantDataDateTime
: public wxVariantData
1089 DECLARE_DYNAMIC_CLASS(wxVariantDataDateTime
)
1092 wxVariantDataDateTime() { }
1093 wxVariantDataDateTime(const wxDateTime
& value
) { m_value
= value
; }
1095 wxVariantDataDateTime(const TIME_STRUCT
* valptr
)
1096 { m_value
= wxDateTime(valptr
->hour
, valptr
->minute
, valptr
->second
); }
1097 wxVariantDataDateTime(const DATE_STRUCT
* valptr
)
1098 { m_value
= wxDateTime(valptr
->day
, (wxDateTime::Month
) (valptr
->month
- 1),valptr
->year
); }
1099 wxVariantDataDateTime(const TIMESTAMP_STRUCT
* valptr
)
1100 { m_value
= wxDateTime(valptr
->day
, (wxDateTime::Month
) (valptr
->month
- 1), valptr
->year
,
1101 valptr
->hour
, valptr
->minute
, valptr
->second
, valptr
->fraction
); }
1104 inline wxDateTime
GetValue() const { return m_value
; }
1105 inline void SetValue(const wxDateTime
& value
) { m_value
= value
; }
1107 virtual void Copy(wxVariantData
& data
);
1108 virtual bool Eq(wxVariantData
& data
) const;
1109 #if wxUSE_STD_IOSTREAM
1110 virtual bool Write(wxSTD ostream
& str
) const;
1112 virtual bool Write(wxString
& str
) const;
1113 #if wxUSE_STD_IOSTREAM
1114 virtual bool Read(wxSTD istream
& str
);
1116 virtual bool Read(wxString
& str
);
1117 virtual wxString
GetType() const { return wxT("datetime"); };
1118 virtual wxVariantData
* Clone() { return new wxVariantDataDateTime
; }
1125 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDateTime
, wxVariantData
)
1127 void wxVariantDataDateTime::Copy(wxVariantData
& data
)
1129 wxASSERT_MSG( (data
.GetType() == wxT("datetime")), wxT("wxVariantDataDateTime::Copy: Can't copy to this type of data") );
1131 wxVariantDataDateTime
& otherData
= (wxVariantDataDateTime
&) data
;
1133 otherData
.m_value
= m_value
;
1137 bool wxVariantDataDateTime::Eq(wxVariantData
& data
) const
1139 wxASSERT_MSG( (data
.GetType() == wxT("datetime")), wxT("wxVariantDataDateTime::Eq: argument mismatch") );
1141 wxVariantDataDateTime
& otherData
= (wxVariantDataDateTime
&) data
;
1143 return (otherData
.m_value
== m_value
);
1147 #if wxUSE_STD_IOSTREAM
1148 bool wxVariantDataDateTime::Write(wxSTD ostream
& str
) const
1156 bool wxVariantDataDateTime::Write(wxString
& str
) const
1158 str
= m_value
.Format();
1163 #if wxUSE_STD_IOSTREAM
1164 bool wxVariantDataDateTime::Read(wxSTD istream
& WXUNUSED(str
))
1172 bool wxVariantDataDateTime::Read(wxString
& str
)
1174 if(! m_value
.ParseDateTime(str
))
1179 // ----------------------------------------------------------------------------
1180 // wxVariantDataArrayString
1181 // ----------------------------------------------------------------------------
1183 class wxVariantDataArrayString
: public wxVariantData
1186 wxVariantDataArrayString() { }
1187 wxVariantDataArrayString(const wxArrayString
& value
) { m_value
= value
; }
1189 wxArrayString
GetValue() const { return m_value
; }
1190 void SetValue(const wxArrayString
& value
) { m_value
= value
; }
1192 virtual void Copy(wxVariantData
& data
);
1193 virtual bool Eq(wxVariantData
& data
) const;
1194 #if wxUSE_STD_IOSTREAM
1195 virtual bool Write(wxSTD ostream
& str
) const;
1197 virtual bool Write(wxString
& str
) const;
1198 #if wxUSE_STD_IOSTREAM
1199 virtual bool Read(wxSTD istream
& str
);
1201 virtual bool Read(wxString
& str
);
1202 virtual wxString
GetType() const { return wxT("arrstring"); };
1203 virtual wxVariantData
* Clone() { return new wxVariantDataArrayString
; }
1206 wxArrayString m_value
;
1208 DECLARE_DYNAMIC_CLASS(wxVariantDataArrayString
)
1211 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataArrayString
, wxVariantData
)
1213 void wxVariantDataArrayString::Copy(wxVariantData
& data
)
1215 wxASSERT_MSG( data
.GetType() == GetType(), wxT("wxVariantDataArrayString::Copy: Can't copy to this type of data") );
1217 wxVariantDataArrayString
& otherData
= (wxVariantDataArrayString
&) data
;
1219 otherData
.m_value
= m_value
;
1223 bool wxVariantDataArrayString::Eq(wxVariantData
& data
) const
1225 wxASSERT_MSG( data
.GetType() == GetType(), wxT("wxVariantDataArrayString::Eq: argument mismatch") );
1227 wxVariantDataArrayString
& otherData
= (wxVariantDataArrayString
&) data
;
1229 return otherData
.m_value
== m_value
;
1233 #if wxUSE_STD_IOSTREAM
1234 bool wxVariantDataArrayString::Write(wxSTD ostream
& str
) const
1242 bool wxVariantDataArrayString::Write(wxString
& str
) const
1244 size_t count
= m_value
.GetCount();
1245 for ( size_t n
= 0; n
< count
; n
++ )
1257 #if wxUSE_STD_IOSTREAM
1258 bool wxVariantDataArrayString::Read(wxSTD istream
& WXUNUSED(str
))
1266 bool wxVariantDataArrayString::Read(wxString
& str
)
1268 wxStringTokenizer
tk(str
, _T(";"));
1269 while ( tk
.HasMoreTokens() )
1271 m_value
.Add(tk
.GetNextToken());
1283 IMPLEMENT_DYNAMIC_CLASS(wxVariant
, wxObject
)
1285 // Construction & destruction
1286 wxVariant::wxVariant()
1288 m_data
= (wxVariantData
*) NULL
;
1291 wxVariant::wxVariant(double val
, const wxString
& name
)
1293 m_data
= new wxVariantDataReal(val
);
1297 wxVariant::wxVariant(long val
, const wxString
& name
)
1299 m_data
= new wxVariantDataLong(val
);
1304 wxVariant::wxVariant(bool val
, const wxString
& name
)
1306 m_data
= new wxVariantDataBool(val
);
1311 wxVariant::wxVariant(char val
, const wxString
& name
)
1313 m_data
= new wxVariantDataChar(val
);
1317 wxVariant::wxVariant(const wxString
& val
, const wxString
& name
)
1319 m_data
= new wxVariantDataString(val
);
1323 wxVariant::wxVariant(const wxChar
* val
, const wxString
& name
)
1325 m_data
= new wxVariantDataString(wxString(val
));
1329 wxVariant::wxVariant(const wxStringList
& val
, const wxString
& name
)
1331 m_data
= new wxVariantDataStringList(val
);
1335 wxVariant::wxVariant(const wxList
& val
, const wxString
& name
) // List of variants
1337 m_data
= new wxVariantDataList(val
);
1341 // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
1342 #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
1343 wxVariant::wxVariant(const wxTime
& val
, const wxString
& name
) // Time
1345 m_data
= new wxVariantDataTime(val
);
1349 wxVariant::wxVariant(const wxDate
& val
, const wxString
& name
) // Date
1351 m_data
= new wxVariantDataDate(val
);
1356 wxVariant::wxVariant(void* val
, const wxString
& name
) // Void ptr
1358 m_data
= new wxVariantDataVoidPtr(val
);
1362 wxVariant::wxVariant(const wxDateTime
& val
, const wxString
& name
) // Date
1364 m_data
= new wxVariantDataDateTime(val
);
1369 wxVariant::wxVariant(const TIME_STRUCT
* valptr
, const wxString
& name
) // Date
1371 m_data
= new wxVariantDataDateTime(valptr
);
1375 wxVariant::wxVariant(const TIMESTAMP_STRUCT
* valptr
, const wxString
& name
) // Date
1377 m_data
= new wxVariantDataDateTime(valptr
);
1381 wxVariant::wxVariant(const DATE_STRUCT
* valptr
, const wxString
& name
) // Date
1383 m_data
= new wxVariantDataDateTime(valptr
);
1386 #endif // wxUSE_ODBC
1388 wxVariant::wxVariant(const wxArrayString
& val
, const wxString
& name
) // Strings
1390 m_data
= new wxVariantDataArrayString(val
);
1394 wxVariant::wxVariant(const wxVariant
& variant
)
1397 if (!variant
.IsNull())
1399 m_data
= (wxVariantData
*) variant
.GetData()->GetClassInfo()->CreateObject();
1400 variant
.m_data
->Copy(*m_data
);
1403 m_data
= (wxVariantData
*) NULL
;
1404 m_name
= variant
.m_name
;
1407 wxVariant::wxVariant(wxVariantData
* data
, const wxString
& name
) // User-defined data
1413 wxVariant::~wxVariant()
1419 // Make NULL (i.e. delete the data)
1420 void wxVariant::MakeNull()
1426 // Generic operators
1428 void wxVariant::operator= (const wxVariant
& variant
)
1430 if (variant
.IsNull())
1436 if (IsNull() || (GetType() != variant
.GetType()))
1440 m_data
= (wxVariantData
*) variant
.GetData()->GetClassInfo()->CreateObject();
1443 variant
.GetData()->Copy(* GetData());
1445 m_name
= variant
.m_name
;
1448 // Assignment using data, e.g.
1449 // myVariant = new wxStringVariantData("hello")
1450 void wxVariant::operator= (wxVariantData
* variantData
)
1453 m_data
= variantData
;
1456 bool wxVariant::operator== (const wxVariant
& variant
) const
1458 if (IsNull() || variant
.IsNull())
1459 return (IsNull() == variant
.IsNull());
1461 return (GetData()->Eq(* variant
.GetData()));
1464 bool wxVariant::operator!= (const wxVariant
& variant
) const
1466 return (!(*this == variant
));
1470 // Specific operators
1471 bool wxVariant::operator== (double value
) const
1474 if (!Convert(&thisValue
))
1477 return (value
== thisValue
);
1480 bool wxVariant::operator!= (double value
) const
1482 return (!((*this) == value
));
1485 void wxVariant::operator= (double value
)
1487 if (GetType() == wxT("double"))
1489 ((wxVariantDataReal
*)GetData())->SetValue(value
);
1495 m_data
= new wxVariantDataReal(value
);
1499 bool wxVariant::operator== (long value
) const
1502 if (!Convert(&thisValue
))
1505 return (value
== thisValue
);
1508 bool wxVariant::operator!= (long value
) const
1510 return (!((*this) == value
));
1513 void wxVariant::operator= (long value
)
1515 if (GetType() == wxT("long"))
1517 ((wxVariantDataLong
*)GetData())->SetValue(value
);
1523 m_data
= new wxVariantDataLong(value
);
1527 bool wxVariant::operator== (char value
) const
1530 if (!Convert(&thisValue
))
1533 return (value
== thisValue
);
1536 bool wxVariant::operator!= (char value
) const
1538 return (!((*this) == value
));
1541 void wxVariant::operator= (char value
)
1543 if (GetType() == wxT("char"))
1545 ((wxVariantDataChar
*)GetData())->SetValue(value
);
1551 m_data
= new wxVariantDataChar(value
);
1556 bool wxVariant::operator== (bool value
) const
1559 if (!Convert(&thisValue
))
1562 return (value
== thisValue
);
1565 bool wxVariant::operator!= (bool value
) const
1567 return (!((*this) == value
));
1570 void wxVariant::operator= (bool value
)
1572 if (GetType() == wxT("bool"))
1574 ((wxVariantDataBool
*)GetData())->SetValue(value
);
1580 m_data
= new wxVariantDataBool(value
);
1585 bool wxVariant::operator== (const wxString
& value
) const
1588 if (!Convert(&thisValue
))
1591 return value
== thisValue
;
1594 bool wxVariant::operator!= (const wxString
& value
) const
1596 return (!((*this) == value
));
1599 void wxVariant::operator= (const wxString
& value
)
1601 if (GetType() == wxT("string"))
1603 ((wxVariantDataString
*)GetData())->SetValue(value
);
1609 m_data
= new wxVariantDataString(value
);
1613 void wxVariant::operator= (const wxChar
* value
)
1615 if (GetType() == wxT("string"))
1617 ((wxVariantDataString
*)GetData())->SetValue(wxString(value
));
1623 m_data
= new wxVariantDataString(wxString(value
));
1627 bool wxVariant::operator== (const wxStringList
& value
) const
1629 wxASSERT_MSG( (GetType() == wxT("stringlist")), wxT("Invalid type for == operator") );
1631 wxVariantDataStringList
other(value
);
1632 return (m_data
->Eq(other
));
1635 bool wxVariant::operator!= (const wxStringList
& value
) const
1637 return (!((*this) == value
));
1640 void wxVariant::operator= (const wxStringList
& value
)
1642 if (GetType() == wxT("stringlist"))
1644 ((wxVariantDataStringList
*)GetData())->SetValue(value
);
1650 m_data
= new wxVariantDataStringList(value
);
1654 bool wxVariant::operator== (const wxList
& value
) const
1656 wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for == operator") );
1658 wxVariantDataList
other(value
);
1659 return (m_data
->Eq(other
));
1662 bool wxVariant::operator!= (const wxList
& value
) const
1664 return (!((*this) == value
));
1667 void wxVariant::operator= (const wxList
& value
)
1669 if (GetType() == wxT("list"))
1671 ((wxVariantDataList
*)GetData())->SetValue(value
);
1677 m_data
= new wxVariantDataList(value
);
1681 // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
1682 #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
1683 bool wxVariant::operator== (const wxTime
& value
) const
1686 if (!Convert(&thisValue
))
1689 return value
== thisValue
;
1692 bool wxVariant::operator!= (const wxTime
& value
) const
1694 return (!((*this) == value
));
1697 void wxVariant::operator= (const wxTime
& value
)
1699 if (GetType() == wxT("time"))
1701 ((wxVariantDataTime
*)GetData())->SetValue(value
);
1707 m_data
= new wxVariantDataTime(value
);
1711 bool wxVariant::operator== (const wxDate
& value
) const
1714 if (!Convert(&thisValue
))
1717 return (value
== thisValue
);
1720 bool wxVariant::operator!= (const wxDate
& value
) const
1722 return (!((*this) == value
));
1725 void wxVariant::operator= (const wxDate
& value
)
1727 if (GetType() == wxT("date"))
1729 ((wxVariantDataTime
*)GetData())->SetValue(value
);
1735 m_data
= new wxVariantDataDate(value
);
1740 bool wxVariant::operator== (void* value
) const
1742 return (value
== ((wxVariantDataVoidPtr
*)GetData())->GetValue());
1745 bool wxVariant::operator!= (void* value
) const
1747 return (!((*this) == (void*) value
));
1750 void wxVariant::operator= (void* value
)
1752 if (GetType() == wxT("void*"))
1754 ((wxVariantDataVoidPtr
*)GetData())->SetValue(value
);
1760 m_data
= new wxVariantDataVoidPtr(value
);
1764 bool wxVariant::operator== (const wxDateTime
& value
) const
1766 wxDateTime thisValue
;
1767 if (!Convert(&thisValue
))
1770 return value
.IsEqualTo(thisValue
);
1773 bool wxVariant::operator!= (const wxDateTime
& value
) const
1775 return (!((*this) == value
));
1778 void wxVariant::operator= (const wxDateTime
& value
)
1780 if (GetType() == wxT("datetime"))
1782 ((wxVariantDataDateTime
*)GetData())->SetValue(value
);
1788 m_data
= new wxVariantDataDateTime(value
);
1793 void wxVariant::operator= (const DATE_STRUCT
* value
)
1797 m_data
= new wxVariantDataDateTime(value
);
1801 void wxVariant::operator= (const TIME_STRUCT
* value
)
1805 m_data
= new wxVariantDataDateTime(value
);
1809 void wxVariant::operator= (const TIMESTAMP_STRUCT
* value
)
1813 m_data
= new wxVariantDataDateTime(value
);
1816 #endif // wxUSE_ODBC
1818 bool wxVariant::operator==(const wxArrayString
& WXUNUSED(value
)) const
1820 wxFAIL_MSG( _T("TODO") );
1825 bool wxVariant::operator!=(const wxArrayString
& value
) const
1827 return !(*this == value
);
1830 void wxVariant::operator=(const wxArrayString
& value
)
1832 if (GetType() == wxT("arrstring"))
1834 ((wxVariantDataArrayString
*)GetData())->SetValue(value
);
1839 m_data
= new wxVariantDataArrayString(value
);
1843 wxArrayString
wxVariant::GetArrayString() const
1845 if ( GetType() == wxT("arrstring") )
1846 return ((wxVariantDataArrayString
*)GetData())->GetValue();
1848 return wxArrayString();
1852 // Treat a list variant as an array
1853 wxVariant
wxVariant::operator[] (size_t idx
) const
1855 wxASSERT_MSG( (GetType() == wxT("list") || GetType() == wxT("stringlist")), wxT("Invalid type for array operator") );
1857 if (GetType() == wxT("list"))
1859 wxVariantDataList
* data
= (wxVariantDataList
*) m_data
;
1860 wxASSERT_MSG( (idx
< (size_t) data
->GetValue().Number()), wxT("Invalid index for array") );
1861 return * (wxVariant
*) (data
->GetValue().Nth(idx
)->Data());
1863 else if (GetType() == wxT("stringlist"))
1865 wxVariantDataStringList
* data
= (wxVariantDataStringList
*) m_data
;
1866 wxASSERT_MSG( (idx
< (size_t) data
->GetValue().Number()), wxT("Invalid index for array") );
1868 wxVariant
variant( wxString( (wxChar
*) (data
->GetValue().Nth(idx
)->Data()) ));
1871 return wxNullVariant
;
1874 wxVariant
& wxVariant::operator[] (size_t idx
)
1876 // We can't return a reference to a variant for a string list, since the string
1877 // is actually stored as a char*, not a variant.
1879 wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for array operator") );
1881 wxVariantDataList
* data
= (wxVariantDataList
*) m_data
;
1882 wxASSERT_MSG( (idx
< (size_t) data
->GetValue().Number()), wxT("Invalid index for array") );
1884 return * (wxVariant
*) (data
->GetValue().Nth(idx
)->Data());
1887 // Return the number of elements in a list
1888 int wxVariant::GetCount() const
1890 wxASSERT_MSG( (GetType() == wxT("list") || GetType() == wxT("stringlist")), wxT("Invalid type for GetCount()") );
1892 if (GetType() == wxT("list"))
1894 wxVariantDataList
* data
= (wxVariantDataList
*) m_data
;
1895 return data
->GetValue().Number();
1897 else if (GetType() == wxT("stringlist"))
1899 wxVariantDataStringList
* data
= (wxVariantDataStringList
*) m_data
;
1900 return data
->GetValue().Number();
1905 wxString
wxVariant::MakeString() const
1910 if (GetData()->Write(str
))
1913 return wxString(wxT(""));
1918 void wxVariant::SetData(wxVariantData
* data
)
1920 if (m_data
) delete m_data
;
1925 // Returns a string representing the type of the variant,
1926 // e.g. "string", "bool", "stringlist", "list", "double", "long"
1927 wxString
wxVariant::GetType() const
1930 return wxString(wxT("null"));
1932 return m_data
->GetType();
1936 bool wxVariant::IsType(const wxString
& type
) const
1938 return (GetType() == type
);
1943 double wxVariant::GetReal() const
1946 if (Convert(& value
))
1950 wxFAIL_MSG(wxT("Could not convert to a real number"));
1955 long wxVariant::GetInteger() const
1958 if (Convert(& value
))
1962 wxFAIL_MSG(wxT("Could not convert to an integer"));
1967 char wxVariant::GetChar() const
1970 if (Convert(& value
))
1974 wxFAIL_MSG(wxT("Could not convert to a char"));
1979 bool wxVariant::GetBool() const
1982 if (Convert(& value
))
1986 wxFAIL_MSG(wxT("Could not convert to a bool"));
1991 wxString
wxVariant::GetString() const
1994 if (!Convert(& value
))
1996 wxFAIL_MSG(wxT("Could not convert to a string"));
2002 // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
2003 #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
2004 wxTime
wxVariant::GetTime() const
2007 if (!Convert(& value
))
2009 wxFAIL_MSG(wxT("Could not convert to a time"));
2015 wxDate
wxVariant::GetDate() const
2018 if (!Convert(& value
))
2020 wxFAIL_MSG(wxT("Could not convert to a date"));
2025 #endif // wxUSE_TIMEDATE
2027 void* wxVariant::GetVoidPtr() const
2029 wxASSERT( (GetType() == wxT("void*")) );
2031 return (void*) ((wxVariantDataVoidPtr
*) m_data
)->GetValue();
2034 wxDateTime
wxVariant::GetDateTime() const
2037 if (!Convert(& value
))
2039 wxFAIL_MSG(wxT("Could not convert to a datetime"));
2045 wxList
& wxVariant::GetList() const
2047 wxASSERT( (GetType() == wxT("list")) );
2049 return (wxList
&) ((wxVariantDataList
*) m_data
)->GetValue();
2052 wxStringList
& wxVariant::GetStringList() const
2054 wxASSERT( (GetType() == wxT("stringlist")) );
2056 return (wxStringList
&) ((wxVariantDataStringList
*) m_data
)->GetValue();
2060 void wxVariant::NullList()
2062 SetData(new wxVariantDataList());
2066 void wxVariant::Append(const wxVariant
& value
)
2068 wxList
& list
= GetList();
2070 list
.Append(new wxVariant(value
));
2073 // Insert at front of list
2074 void wxVariant::Insert(const wxVariant
& value
)
2076 wxList
& list
= GetList();
2078 list
.Insert(new wxVariant(value
));
2081 // Returns TRUE if the variant is a member of the list
2082 bool wxVariant::Member(const wxVariant
& value
) const
2084 wxList
& list
= GetList();
2086 wxNode
* node
= list
.First();
2089 wxVariant
* other
= (wxVariant
*) node
->Data();
2090 if (value
== *other
)
2092 node
= node
->Next();
2097 // Deletes the nth element of the list
2098 bool wxVariant::Delete(int item
)
2100 wxList
& list
= GetList();
2102 wxASSERT_MSG( (item
< list
.Number()), wxT("Invalid index to Delete") );
2103 wxNode
* node
= list
.Nth(item
);
2104 wxVariant
* variant
= (wxVariant
*) node
->Data();
2111 void wxVariant::ClearList()
2113 if (!IsNull() && (GetType() == wxT("list")))
2115 ((wxVariantDataList
*) m_data
)->Clear();
2119 if (GetType() != wxT("list"))
2124 m_data
= new wxVariantDataList
;
2129 bool wxVariant::Convert(long* value
) const
2131 wxString
type(GetType());
2132 if (type
== wxT("double"))
2133 *value
= (long) (((wxVariantDataReal
*)GetData())->GetValue());
2134 else if (type
== wxT("long"))
2135 *value
= ((wxVariantDataLong
*)GetData())->GetValue();
2137 else if (type
== wxT("bool"))
2138 *value
= (long) (((wxVariantDataBool
*)GetData())->GetValue());
2140 else if (type
== wxT("string"))
2141 *value
= wxAtol((const wxChar
*) ((wxVariantDataString
*)GetData())->GetValue());
2148 bool wxVariant::Convert(bool* value
) const
2150 wxString
type(GetType());
2151 if (type
== wxT("double"))
2152 *value
= ((int) (((wxVariantDataReal
*)GetData())->GetValue()) != 0);
2153 else if (type
== wxT("long"))
2154 *value
= (((wxVariantDataLong
*)GetData())->GetValue() != 0);
2156 else if (type
== wxT("bool"))
2157 *value
= ((wxVariantDataBool
*)GetData())->GetValue();
2159 else if (type
== wxT("string"))
2161 wxString
val(((wxVariantDataString
*)GetData())->GetValue());
2163 if (val
== wxT("true") || val
== wxT("yes"))
2165 else if (val
== wxT("false") || val
== wxT("no"))
2176 bool wxVariant::Convert(double* value
) const
2178 wxString
type(GetType());
2179 if (type
== wxT("double"))
2180 *value
= ((wxVariantDataReal
*)GetData())->GetValue();
2181 else if (type
== wxT("long"))
2182 *value
= (double) (((wxVariantDataLong
*)GetData())->GetValue());
2184 else if (type
== wxT("bool"))
2185 *value
= (double) (((wxVariantDataBool
*)GetData())->GetValue());
2187 else if (type
== wxT("string"))
2188 *value
= (double) wxAtof((const wxChar
*) ((wxVariantDataString
*)GetData())->GetValue());
2195 bool wxVariant::Convert(char* value
) const
2197 wxString
type(GetType());
2198 if (type
== wxT("char"))
2199 *value
= ((wxVariantDataChar
*)GetData())->GetValue();
2200 else if (type
== wxT("long"))
2201 *value
= (char) (((wxVariantDataLong
*)GetData())->GetValue());
2203 else if (type
== wxT("bool"))
2204 *value
= (char) (((wxVariantDataBool
*)GetData())->GetValue());
2212 bool wxVariant::Convert(wxString
* value
) const
2214 *value
= MakeString();
2218 // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
2219 #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
2220 bool wxVariant::Convert(wxTime
* value
) const
2222 wxString
type(GetType());
2223 if (type
== wxT("time"))
2224 *value
= ((wxVariantDataTime
*)GetData())->GetValue();
2225 else if (type
== wxT("date"))
2226 *value
= wxTime(((wxVariantDataDate
*)GetData())->GetValue());
2233 bool wxVariant::Convert(wxDate
* value
) const
2235 wxString
type(GetType());
2236 if (type
== wxT("date"))
2237 *value
= ((wxVariantDataDate
*)GetData())->GetValue();
2243 #endif // wxUSE_TIMEDATE
2245 bool wxVariant::Convert(wxDateTime
* value
) const
2247 wxString
type(GetType());
2248 if (type
== wxT("datetime"))
2250 *value
= ((wxVariantDataDateTime
*)GetData())->GetValue();
2253 // Fallback to string conversion
2255 return Convert(&val
) && (value
->ParseDate(val
));