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