]> git.saurik.com Git - wxWidgets.git/blob - include/wx/longlong.h
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Build fix for wxOSX after removing position in MacCreateKeyEvent().
[wxWidgets.git] / include / wx / longlong.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/longlong.h
3 // Purpose: declaration of wxLongLong class - best implementation of a 64
4 // bit integer for the current platform.
5 // Author: Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
6 // Modified by:
7 // Created: 10.02.99
8 // RCS-ID: $Id$
9 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 #ifndef _WX_LONGLONG_H
14 #define _WX_LONGLONG_H
15
16 #include "wx/defs.h"
17
18 #if wxUSE_LONGLONG
19
20 #include "wx/string.h"
21
22 #include <limits.h> // for LONG_MAX
23
24 // define this to compile wxLongLongWx in "test" mode: the results of all
25 // calculations will be compared with the real results taken from
26 // wxLongLongNative -- this is extremely useful to find the bugs in
27 // wxLongLongWx class!
28
29 // #define wxLONGLONG_TEST_MODE
30
31 #ifdef wxLONGLONG_TEST_MODE
32 #define wxUSE_LONGLONG_WX 1
33 #define wxUSE_LONGLONG_NATIVE 1
34 #endif // wxLONGLONG_TEST_MODE
35
36 // ----------------------------------------------------------------------------
37 // decide upon which class we will use
38 // ----------------------------------------------------------------------------
39
40 #ifndef wxLongLong_t
41 // both warning and pragma warning are not portable, but at least an
42 // unknown pragma should never be an error -- except that, actually, some
43 // broken compilers don't like it, so we have to disable it in this case
44 // <sigh>
45 #ifdef __GNUC__
46 #warning "Your compiler does not appear to support 64 bit "\
47 "integers, using emulation class instead.\n" \
48 "Please report your compiler version to " \
49 "wx-dev@lists.wxwidgets.org!"
50 #elif !(defined(__WATCOMC__) || defined(__VISAGECPP__))
51 #pragma warning "Your compiler does not appear to support 64 bit "\
52 "integers, using emulation class instead.\n" \
53 "Please report your compiler version to " \
54 "wx-dev@lists.wxwidgets.org!"
55 #endif
56
57 #define wxUSE_LONGLONG_WX 1
58 #endif // compiler
59
60 // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
61 // to disable automatic testing (useful for the test program which defines
62 // both classes) but by default we only use one class
63 #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
64 // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set:
65 // this is useful in test programs and only there
66 #ifndef wxUSE_LONGLONG_NATIVE
67 #define wxUSE_LONGLONG_NATIVE 0
68 #endif
69
70 class WXDLLIMPEXP_FWD_BASE wxLongLongWx;
71 class WXDLLIMPEXP_FWD_BASE wxULongLongWx;
72 #if defined(__VISUALC__) && !defined(__WIN32__)
73 #define wxLongLong wxLongLongWx
74 #define wxULongLong wxULongLongWx
75 #else
76 typedef wxLongLongWx wxLongLong;
77 typedef wxULongLongWx wxULongLong;
78 #endif
79
80 #else
81 // if nothing is defined, use native implementation by default, of course
82 #ifndef wxUSE_LONGLONG_NATIVE
83 #define wxUSE_LONGLONG_NATIVE 1
84 #endif
85 #endif
86
87 #ifndef wxUSE_LONGLONG_WX
88 #define wxUSE_LONGLONG_WX 0
89 class WXDLLIMPEXP_FWD_BASE wxLongLongNative;
90 class WXDLLIMPEXP_FWD_BASE wxULongLongNative;
91 typedef wxLongLongNative wxLongLong;
92 typedef wxULongLongNative wxULongLong;
93 #endif
94
95 // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should
96 // typedef wxLongLong as it wants, we don't do it
97
98 // ----------------------------------------------------------------------------
99 // choose the appropriate class
100 // ----------------------------------------------------------------------------
101
102 // we use iostream for wxLongLong output
103 #include "wx/iosfwrap.h"
104
105 #if wxUSE_LONGLONG_NATIVE
106
107 class WXDLLIMPEXP_BASE wxLongLongNative
108 {
109 public:
110 // ctors
111 // default ctor initializes to 0
112 wxLongLongNative() : m_ll(0) { }
113 // from long long
114 wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }
115 // from 2 longs
116 wxLongLongNative(wxInt32 hi, wxUint32 lo)
117 {
118 // cast to wxLongLong_t first to avoid precision loss!
119 m_ll = ((wxLongLong_t) hi) << 32;
120 m_ll |= (wxLongLong_t) lo;
121 }
122 #if wxUSE_LONGLONG_WX
123 wxLongLongNative(wxLongLongWx ll);
124 #endif
125
126 // default copy ctor is ok
127
128 // no dtor
129
130 // assignment operators
131 // from native 64 bit integer
132 #ifndef wxLongLongIsLong
133 wxLongLongNative& operator=(wxLongLong_t ll)
134 { m_ll = ll; return *this; }
135 wxLongLongNative& operator=(wxULongLong_t ll)
136 { m_ll = ll; return *this; }
137 #endif // !wxLongLongNative
138 wxLongLongNative& operator=(const wxULongLongNative &ll);
139 wxLongLongNative& operator=(int l)
140 { m_ll = l; return *this; }
141 wxLongLongNative& operator=(long l)
142 { m_ll = l; return *this; }
143 wxLongLongNative& operator=(unsigned int l)
144 { m_ll = l; return *this; }
145 wxLongLongNative& operator=(unsigned long l)
146 { m_ll = l; return *this; }
147 #if wxUSE_LONGLONG_WX
148 wxLongLongNative& operator=(wxLongLongWx ll);
149 wxLongLongNative& operator=(const class wxULongLongWx &ll);
150 #endif
151
152
153 // from double: this one has an explicit name because otherwise we
154 // would have ambiguity with "ll = int" and also because we don't want
155 // to have implicit conversions between doubles and wxLongLongs
156 wxLongLongNative& Assign(double d)
157 { m_ll = (wxLongLong_t)d; return *this; }
158
159 // assignment operators from wxLongLongNative is ok
160
161 // accessors
162 // get high part
163 wxInt32 GetHi() const
164 { return wx_truncate_cast(wxInt32, m_ll >> 32); }
165 // get low part
166 wxUint32 GetLo() const
167 { return wx_truncate_cast(wxUint32, m_ll); }
168
169 // get absolute value
170 wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
171 wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
172
173 // convert to native long long
174 wxLongLong_t GetValue() const { return m_ll; }
175
176 // convert to long with range checking in debug mode (only!)
177 long ToLong() const
178 {
179 wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
180 wxT("wxLongLong to long conversion loss of precision") );
181
182 return wx_truncate_cast(long, m_ll);
183 }
184
185 // convert to double
186 double ToDouble() const { return wx_truncate_cast(double, m_ll); }
187
188 // don't provide implicit conversion to wxLongLong_t or we will have an
189 // ambiguity for all arithmetic operations
190 //operator wxLongLong_t() const { return m_ll; }
191
192 // operations
193 // addition
194 wxLongLongNative operator+(const wxLongLongNative& ll) const
195 { return wxLongLongNative(m_ll + ll.m_ll); }
196 wxLongLongNative& operator+=(const wxLongLongNative& ll)
197 { m_ll += ll.m_ll; return *this; }
198
199 wxLongLongNative operator+(const wxLongLong_t ll) const
200 { return wxLongLongNative(m_ll + ll); }
201 wxLongLongNative& operator+=(const wxLongLong_t ll)
202 { m_ll += ll; return *this; }
203
204 // pre increment
205 wxLongLongNative& operator++()
206 { m_ll++; return *this; }
207
208 // post increment
209 wxLongLongNative operator++(int)
210 { wxLongLongNative value(*this); m_ll++; return value; }
211
212 // negation operator
213 wxLongLongNative operator-() const
214 { return wxLongLongNative(-m_ll); }
215 wxLongLongNative& Negate() { m_ll = -m_ll; return *this; }
216
217 // subtraction
218 wxLongLongNative operator-(const wxLongLongNative& ll) const
219 { return wxLongLongNative(m_ll - ll.m_ll); }
220 wxLongLongNative& operator-=(const wxLongLongNative& ll)
221 { m_ll -= ll.m_ll; return *this; }
222
223 wxLongLongNative operator-(const wxLongLong_t ll) const
224 { return wxLongLongNative(m_ll - ll); }
225 wxLongLongNative& operator-=(const wxLongLong_t ll)
226 { m_ll -= ll; return *this; }
227
228 // pre decrement
229 wxLongLongNative& operator--()
230 { m_ll--; return *this; }
231
232 // post decrement
233 wxLongLongNative operator--(int)
234 { wxLongLongNative value(*this); m_ll--; return value; }
235
236 // shifts
237 // left shift
238 wxLongLongNative operator<<(int shift) const
239 { return wxLongLongNative(m_ll << shift); }
240 wxLongLongNative& operator<<=(int shift)
241 { m_ll <<= shift; return *this; }
242
243 // right shift
244 wxLongLongNative operator>>(int shift) const
245 { return wxLongLongNative(m_ll >> shift); }
246 wxLongLongNative& operator>>=(int shift)
247 { m_ll >>= shift; return *this; }
248
249 // bitwise operators
250 wxLongLongNative operator&(const wxLongLongNative& ll) const
251 { return wxLongLongNative(m_ll & ll.m_ll); }
252 wxLongLongNative& operator&=(const wxLongLongNative& ll)
253 { m_ll &= ll.m_ll; return *this; }
254
255 wxLongLongNative operator|(const wxLongLongNative& ll) const
256 { return wxLongLongNative(m_ll | ll.m_ll); }
257 wxLongLongNative& operator|=(const wxLongLongNative& ll)
258 { m_ll |= ll.m_ll; return *this; }
259
260 wxLongLongNative operator^(const wxLongLongNative& ll) const
261 { return wxLongLongNative(m_ll ^ ll.m_ll); }
262 wxLongLongNative& operator^=(const wxLongLongNative& ll)
263 { m_ll ^= ll.m_ll; return *this; }
264
265 // multiplication/division
266 wxLongLongNative operator*(const wxLongLongNative& ll) const
267 { return wxLongLongNative(m_ll * ll.m_ll); }
268 wxLongLongNative operator*(long l) const
269 { return wxLongLongNative(m_ll * l); }
270 wxLongLongNative& operator*=(const wxLongLongNative& ll)
271 { m_ll *= ll.m_ll; return *this; }
272 wxLongLongNative& operator*=(long l)
273 { m_ll *= l; return *this; }
274
275 wxLongLongNative operator/(const wxLongLongNative& ll) const
276 { return wxLongLongNative(m_ll / ll.m_ll); }
277 wxLongLongNative operator/(long l) const
278 { return wxLongLongNative(m_ll / l); }
279 wxLongLongNative& operator/=(const wxLongLongNative& ll)
280 { m_ll /= ll.m_ll; return *this; }
281 wxLongLongNative& operator/=(long l)
282 { m_ll /= l; return *this; }
283
284 wxLongLongNative operator%(const wxLongLongNative& ll) const
285 { return wxLongLongNative(m_ll % ll.m_ll); }
286 wxLongLongNative operator%(long l) const
287 { return wxLongLongNative(m_ll % l); }
288
289 // comparison
290 bool operator==(const wxLongLongNative& ll) const
291 { return m_ll == ll.m_ll; }
292 bool operator==(long l) const
293 { return m_ll == l; }
294 bool operator!=(const wxLongLongNative& ll) const
295 { return m_ll != ll.m_ll; }
296 bool operator!=(long l) const
297 { return m_ll != l; }
298 bool operator<(const wxLongLongNative& ll) const
299 { return m_ll < ll.m_ll; }
300 bool operator<(long l) const
301 { return m_ll < l; }
302 bool operator>(const wxLongLongNative& ll) const
303 { return m_ll > ll.m_ll; }
304 bool operator>(long l) const
305 { return m_ll > l; }
306 bool operator<=(const wxLongLongNative& ll) const
307 { return m_ll <= ll.m_ll; }
308 bool operator<=(long l) const
309 { return m_ll <= l; }
310 bool operator>=(const wxLongLongNative& ll) const
311 { return m_ll >= ll.m_ll; }
312 bool operator>=(long l) const
313 { return m_ll >= l; }
314
315 // miscellaneous
316
317 // return the string representation of this number
318 wxString ToString() const;
319
320 // conversion to byte array: returns a pointer to static buffer!
321 void *asArray() const;
322
323 #if wxUSE_STD_IOSTREAM
324 // input/output
325 friend WXDLLIMPEXP_BASE
326 wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
327 #endif
328
329 friend WXDLLIMPEXP_BASE
330 wxString& operator<<(wxString&, const wxLongLongNative&);
331
332 #if wxUSE_STREAMS
333 friend WXDLLIMPEXP_BASE
334 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongNative&);
335 friend WXDLLIMPEXP_BASE
336 class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongNative&);
337 #endif
338
339 private:
340 wxLongLong_t m_ll;
341 };
342
343
344 class WXDLLIMPEXP_BASE wxULongLongNative
345 {
346 public:
347 // ctors
348 // default ctor initializes to 0
349 wxULongLongNative() : m_ll(0) { }
350 // from long long
351 wxULongLongNative(wxULongLong_t ll) : m_ll(ll) { }
352 // from 2 longs
353 wxULongLongNative(wxUint32 hi, wxUint32 lo) : m_ll(0)
354 {
355 // cast to wxLongLong_t first to avoid precision loss!
356 m_ll = ((wxULongLong_t) hi) << 32;
357 m_ll |= (wxULongLong_t) lo;
358 }
359
360 #if wxUSE_LONGLONG_WX
361 wxULongLongNative(const class wxULongLongWx &ll);
362 #endif
363
364 // default copy ctor is ok
365
366 // no dtor
367
368 // assignment operators
369 // from native 64 bit integer
370 #ifndef wxLongLongIsLong
371 wxULongLongNative& operator=(wxULongLong_t ll)
372 { m_ll = ll; return *this; }
373 wxULongLongNative& operator=(wxLongLong_t ll)
374 { m_ll = ll; return *this; }
375 #endif // !wxLongLongNative
376 wxULongLongNative& operator=(int l)
377 { m_ll = l; return *this; }
378 wxULongLongNative& operator=(long l)
379 { m_ll = l; return *this; }
380 wxULongLongNative& operator=(unsigned int l)
381 { m_ll = l; return *this; }
382 wxULongLongNative& operator=(unsigned long l)
383 { m_ll = l; return *this; }
384 wxULongLongNative& operator=(const wxLongLongNative &ll)
385 { m_ll = ll.GetValue(); return *this; }
386 #if wxUSE_LONGLONG_WX
387 wxULongLongNative& operator=(wxLongLongWx ll);
388 wxULongLongNative& operator=(const class wxULongLongWx &ll);
389 #endif
390
391 // assignment operators from wxULongLongNative is ok
392
393 // accessors
394 // get high part
395 wxUint32 GetHi() const
396 { return wx_truncate_cast(wxUint32, m_ll >> 32); }
397 // get low part
398 wxUint32 GetLo() const
399 { return wx_truncate_cast(wxUint32, m_ll); }
400
401 // convert to native ulong long
402 wxULongLong_t GetValue() const { return m_ll; }
403
404 // convert to ulong with range checking in debug mode (only!)
405 unsigned long ToULong() const
406 {
407 wxASSERT_MSG( m_ll <= ULONG_MAX,
408 wxT("wxULongLong to long conversion loss of precision") );
409
410 return wx_truncate_cast(unsigned long, m_ll);
411 }
412
413 // convert to double
414 //
415 // For some completely obscure reasons compiling the cast below with
416 // VC6 in DLL builds only (!) results in "error C2520: conversion from
417 // unsigned __int64 to double not implemented, use signed __int64" so
418 // we must use a different version for that compiler.
419 #ifdef __VISUALC6__
420 double ToDouble() const;
421 #else
422 double ToDouble() const { return wx_truncate_cast(double, m_ll); }
423 #endif
424
425 // operations
426 // addition
427 wxULongLongNative operator+(const wxULongLongNative& ll) const
428 { return wxULongLongNative(m_ll + ll.m_ll); }
429 wxULongLongNative& operator+=(const wxULongLongNative& ll)
430 { m_ll += ll.m_ll; return *this; }
431
432 wxULongLongNative operator+(const wxULongLong_t ll) const
433 { return wxULongLongNative(m_ll + ll); }
434 wxULongLongNative& operator+=(const wxULongLong_t ll)
435 { m_ll += ll; return *this; }
436
437 // pre increment
438 wxULongLongNative& operator++()
439 { m_ll++; return *this; }
440
441 // post increment
442 wxULongLongNative operator++(int)
443 { wxULongLongNative value(*this); m_ll++; return value; }
444
445 // subtraction
446 wxULongLongNative operator-(const wxULongLongNative& ll) const
447 { return wxULongLongNative(m_ll - ll.m_ll); }
448 wxULongLongNative& operator-=(const wxULongLongNative& ll)
449 { m_ll -= ll.m_ll; return *this; }
450
451 wxULongLongNative operator-(const wxULongLong_t ll) const
452 { return wxULongLongNative(m_ll - ll); }
453 wxULongLongNative& operator-=(const wxULongLong_t ll)
454 { m_ll -= ll; return *this; }
455
456 // pre decrement
457 wxULongLongNative& operator--()
458 { m_ll--; return *this; }
459
460 // post decrement
461 wxULongLongNative operator--(int)
462 { wxULongLongNative value(*this); m_ll--; return value; }
463
464 // shifts
465 // left shift
466 wxULongLongNative operator<<(int shift) const
467 { return wxULongLongNative(m_ll << shift); }
468 wxULongLongNative& operator<<=(int shift)
469 { m_ll <<= shift; return *this; }
470
471 // right shift
472 wxULongLongNative operator>>(int shift) const
473 { return wxULongLongNative(m_ll >> shift); }
474 wxULongLongNative& operator>>=(int shift)
475 { m_ll >>= shift; return *this; }
476
477 // bitwise operators
478 wxULongLongNative operator&(const wxULongLongNative& ll) const
479 { return wxULongLongNative(m_ll & ll.m_ll); }
480 wxULongLongNative& operator&=(const wxULongLongNative& ll)
481 { m_ll &= ll.m_ll; return *this; }
482
483 wxULongLongNative operator|(const wxULongLongNative& ll) const
484 { return wxULongLongNative(m_ll | ll.m_ll); }
485 wxULongLongNative& operator|=(const wxULongLongNative& ll)
486 { m_ll |= ll.m_ll; return *this; }
487
488 wxULongLongNative operator^(const wxULongLongNative& ll) const
489 { return wxULongLongNative(m_ll ^ ll.m_ll); }
490 wxULongLongNative& operator^=(const wxULongLongNative& ll)
491 { m_ll ^= ll.m_ll; return *this; }
492
493 // multiplication/division
494 wxULongLongNative operator*(const wxULongLongNative& ll) const
495 { return wxULongLongNative(m_ll * ll.m_ll); }
496 wxULongLongNative operator*(unsigned long l) const
497 { return wxULongLongNative(m_ll * l); }
498 wxULongLongNative& operator*=(const wxULongLongNative& ll)
499 { m_ll *= ll.m_ll; return *this; }
500 wxULongLongNative& operator*=(unsigned long l)
501 { m_ll *= l; return *this; }
502
503 wxULongLongNative operator/(const wxULongLongNative& ll) const
504 { return wxULongLongNative(m_ll / ll.m_ll); }
505 wxULongLongNative operator/(unsigned long l) const
506 { return wxULongLongNative(m_ll / l); }
507 wxULongLongNative& operator/=(const wxULongLongNative& ll)
508 { m_ll /= ll.m_ll; return *this; }
509 wxULongLongNative& operator/=(unsigned long l)
510 { m_ll /= l; return *this; }
511
512 wxULongLongNative operator%(const wxULongLongNative& ll) const
513 { return wxULongLongNative(m_ll % ll.m_ll); }
514 wxULongLongNative operator%(unsigned long l) const
515 { return wxULongLongNative(m_ll % l); }
516
517 // comparison
518 bool operator==(const wxULongLongNative& ll) const
519 { return m_ll == ll.m_ll; }
520 bool operator==(unsigned long l) const
521 { return m_ll == l; }
522 bool operator!=(const wxULongLongNative& ll) const
523 { return m_ll != ll.m_ll; }
524 bool operator!=(unsigned long l) const
525 { return m_ll != l; }
526 bool operator<(const wxULongLongNative& ll) const
527 { return m_ll < ll.m_ll; }
528 bool operator<(unsigned long l) const
529 { return m_ll < l; }
530 bool operator>(const wxULongLongNative& ll) const
531 { return m_ll > ll.m_ll; }
532 bool operator>(unsigned long l) const
533 { return m_ll > l; }
534 bool operator<=(const wxULongLongNative& ll) const
535 { return m_ll <= ll.m_ll; }
536 bool operator<=(unsigned long l) const
537 { return m_ll <= l; }
538 bool operator>=(const wxULongLongNative& ll) const
539 { return m_ll >= ll.m_ll; }
540 bool operator>=(unsigned long l) const
541 { return m_ll >= l; }
542
543 // miscellaneous
544
545 // return the string representation of this number
546 wxString ToString() const;
547
548 // conversion to byte array: returns a pointer to static buffer!
549 void *asArray() const;
550
551 #if wxUSE_STD_IOSTREAM
552 // input/output
553 friend WXDLLIMPEXP_BASE
554 wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
555 #endif
556
557 friend WXDLLIMPEXP_BASE
558 wxString& operator<<(wxString&, const wxULongLongNative&);
559
560 #if wxUSE_STREAMS
561 friend WXDLLIMPEXP_BASE
562 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongNative&);
563 friend WXDLLIMPEXP_BASE
564 class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongNative&);
565 #endif
566
567 private:
568 wxULongLong_t m_ll;
569 };
570
571 inline
572 wxLongLongNative& wxLongLongNative::operator=(const wxULongLongNative &ll)
573 {
574 m_ll = ll.GetValue();
575 return *this;
576 }
577
578 #endif // wxUSE_LONGLONG_NATIVE
579
580 #if wxUSE_LONGLONG_WX
581
582 class WXDLLIMPEXP_BASE wxLongLongWx
583 {
584 public:
585 // ctors
586 // default ctor initializes to 0
587 wxLongLongWx()
588 {
589 m_lo = m_hi = 0;
590
591 #ifdef wxLONGLONG_TEST_MODE
592 m_ll = 0;
593
594 Check();
595 #endif // wxLONGLONG_TEST_MODE
596 }
597 // from long
598 wxLongLongWx(long l) { *this = l; }
599 // from 2 longs
600 wxLongLongWx(long hi, unsigned long lo)
601 {
602 m_hi = hi;
603 m_lo = lo;
604
605 #ifdef wxLONGLONG_TEST_MODE
606 m_ll = hi;
607 m_ll <<= 32;
608 m_ll |= lo;
609
610 Check();
611 #endif // wxLONGLONG_TEST_MODE
612 }
613
614 // default copy ctor is ok in both cases
615
616 // no dtor
617
618 // assignment operators
619 // from long
620 wxLongLongWx& operator=(long l)
621 {
622 m_lo = l;
623 m_hi = (l < 0 ? -1l : 0l);
624
625 #ifdef wxLONGLONG_TEST_MODE
626 m_ll = l;
627
628 Check();
629 #endif // wxLONGLONG_TEST_MODE
630
631 return *this;
632 }
633 // from int
634 wxLongLongWx& operator=(int l)
635 {
636 return operator=((long)l);
637 }
638
639 wxLongLongWx& operator=(unsigned long l)
640 {
641 m_lo = l;
642 m_hi = 0;
643
644 #ifdef wxLONGLONG_TEST_MODE
645 m_ll = l;
646
647 Check();
648 #endif // wxLONGLONG_TEST_MODE
649
650 return *this;
651 }
652
653 wxLongLongWx& operator=(unsigned int l)
654 {
655 return operator=((unsigned long)l);
656 }
657
658 wxLongLongWx& operator=(const class wxULongLongWx &ll);
659
660 // from double
661 wxLongLongWx& Assign(double d);
662 // can't have assignment operator from 2 longs
663
664 // accessors
665 // get high part
666 long GetHi() const { return m_hi; }
667 // get low part
668 unsigned long GetLo() const { return m_lo; }
669
670 // get absolute value
671 wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
672 wxLongLongWx& Abs()
673 {
674 if ( m_hi < 0 )
675 m_hi = -m_hi;
676
677 #ifdef wxLONGLONG_TEST_MODE
678 if ( m_ll < 0 )
679 m_ll = -m_ll;
680
681 Check();
682 #endif // wxLONGLONG_TEST_MODE
683
684 return *this;
685 }
686
687 // convert to long with range checking in debug mode (only!)
688 long ToLong() const
689 {
690 wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l),
691 wxT("wxLongLong to long conversion loss of precision") );
692
693 return (long)m_lo;
694 }
695
696 // convert to double
697 double ToDouble() const;
698
699 // operations
700 // addition
701 wxLongLongWx operator+(const wxLongLongWx& ll) const;
702 wxLongLongWx& operator+=(const wxLongLongWx& ll);
703 wxLongLongWx operator+(long l) const;
704 wxLongLongWx& operator+=(long l);
705
706 // pre increment operator
707 wxLongLongWx& operator++();
708
709 // post increment operator
710 wxLongLongWx& operator++(int) { return ++(*this); }
711
712 // negation operator
713 wxLongLongWx operator-() const;
714 wxLongLongWx& Negate();
715
716 // subraction
717 wxLongLongWx operator-(const wxLongLongWx& ll) const;
718 wxLongLongWx& operator-=(const wxLongLongWx& ll);
719
720 // pre decrement operator
721 wxLongLongWx& operator--();
722
723 // post decrement operator
724 wxLongLongWx& operator--(int) { return --(*this); }
725
726 // shifts
727 // left shift
728 wxLongLongWx operator<<(int shift) const;
729 wxLongLongWx& operator<<=(int shift);
730
731 // right shift
732 wxLongLongWx operator>>(int shift) const;
733 wxLongLongWx& operator>>=(int shift);
734
735 // bitwise operators
736 wxLongLongWx operator&(const wxLongLongWx& ll) const;
737 wxLongLongWx& operator&=(const wxLongLongWx& ll);
738 wxLongLongWx operator|(const wxLongLongWx& ll) const;
739 wxLongLongWx& operator|=(const wxLongLongWx& ll);
740 wxLongLongWx operator^(const wxLongLongWx& ll) const;
741 wxLongLongWx& operator^=(const wxLongLongWx& ll);
742 wxLongLongWx operator~() const;
743
744 // comparison
745 bool operator==(const wxLongLongWx& ll) const
746 { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
747 #if wxUSE_LONGLONG_NATIVE
748 bool operator==(const wxLongLongNative& ll) const
749 { return m_lo == ll.GetLo() && m_hi == ll.GetHi(); }
750 #endif
751 bool operator!=(const wxLongLongWx& ll) const
752 { return !(*this == ll); }
753 bool operator<(const wxLongLongWx& ll) const;
754 bool operator>(const wxLongLongWx& ll) const;
755 bool operator<=(const wxLongLongWx& ll) const
756 { return *this < ll || *this == ll; }
757 bool operator>=(const wxLongLongWx& ll) const
758 { return *this > ll || *this == ll; }
759
760 bool operator<(long l) const { return *this < wxLongLongWx(l); }
761 bool operator>(long l) const { return *this > wxLongLongWx(l); }
762 bool operator==(long l) const
763 {
764 return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l)
765 : (m_hi == -1 && m_lo == (unsigned long)l);
766 }
767
768 bool operator<=(long l) const { return *this < l || *this == l; }
769 bool operator>=(long l) const { return *this > l || *this == l; }
770
771 // multiplication
772 wxLongLongWx operator*(const wxLongLongWx& ll) const;
773 wxLongLongWx& operator*=(const wxLongLongWx& ll);
774
775 // division
776 wxLongLongWx operator/(const wxLongLongWx& ll) const;
777 wxLongLongWx& operator/=(const wxLongLongWx& ll);
778
779 wxLongLongWx operator%(const wxLongLongWx& ll) const;
780
781 void Divide(const wxLongLongWx& divisor,
782 wxLongLongWx& quotient,
783 wxLongLongWx& remainder) const;
784
785 // input/output
786
787 // return the string representation of this number
788 wxString ToString() const;
789
790 void *asArray() const;
791
792 #if wxUSE_STD_IOSTREAM
793 friend WXDLLIMPEXP_BASE
794 wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
795 #endif // wxUSE_STD_IOSTREAM
796
797 friend WXDLLIMPEXP_BASE
798 wxString& operator<<(wxString&, const wxLongLongWx&);
799
800 #if wxUSE_STREAMS
801 friend WXDLLIMPEXP_BASE
802 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongWx&);
803 friend WXDLLIMPEXP_BASE
804 class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongWx&);
805 #endif
806
807 private:
808 // long is at least 32 bits, so represent our 64bit number as 2 longs
809
810 long m_hi; // signed bit is in the high part
811 unsigned long m_lo;
812
813 #ifdef wxLONGLONG_TEST_MODE
814 void Check()
815 {
816 wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
817 }
818
819 wxLongLong_t m_ll;
820 #endif // wxLONGLONG_TEST_MODE
821 };
822
823
824 class WXDLLIMPEXP_BASE wxULongLongWx
825 {
826 public:
827 // ctors
828 // default ctor initializes to 0
829 wxULongLongWx()
830 {
831 m_lo = m_hi = 0;
832
833 #ifdef wxLONGLONG_TEST_MODE
834 m_ll = 0;
835
836 Check();
837 #endif // wxLONGLONG_TEST_MODE
838 }
839 // from ulong
840 wxULongLongWx(unsigned long l) { *this = l; }
841 // from 2 ulongs
842 wxULongLongWx(unsigned long hi, unsigned long lo)
843 {
844 m_hi = hi;
845 m_lo = lo;
846
847 #ifdef wxLONGLONG_TEST_MODE
848 m_ll = hi;
849 m_ll <<= 32;
850 m_ll |= lo;
851
852 Check();
853 #endif // wxLONGLONG_TEST_MODE
854 }
855
856 // from signed to unsigned
857 wxULongLongWx(wxLongLongWx ll)
858 {
859 wxASSERT(ll.GetHi() >= 0);
860 m_hi = (unsigned long)ll.GetHi();
861 m_lo = ll.GetLo();
862 }
863
864 // default copy ctor is ok in both cases
865
866 // no dtor
867
868 // assignment operators
869 // from long
870 wxULongLongWx& operator=(unsigned long l)
871 {
872 m_lo = l;
873 m_hi = 0;
874
875 #ifdef wxLONGLONG_TEST_MODE
876 m_ll = l;
877
878 Check();
879 #endif // wxLONGLONG_TEST_MODE
880
881 return *this;
882 }
883 wxULongLongWx& operator=(long l)
884 {
885 m_lo = l;
886 m_hi = (unsigned long) ((l<0) ? -1l : 0);
887
888 #ifdef wxLONGLONG_TEST_MODE
889 m_ll = (wxULongLong_t) (wxLongLong_t) l;
890
891 Check();
892 #endif // wxLONGLONG_TEST_MODE
893
894 return *this;
895 }
896 wxULongLongWx& operator=(const class wxLongLongWx &ll) {
897 // Should we use an assert like it was before in the constructor?
898 // wxASSERT(ll.GetHi() >= 0);
899 m_hi = (unsigned long)ll.GetHi();
900 m_lo = ll.GetLo();
901 return *this;
902 }
903
904 // can't have assignment operator from 2 longs
905
906 // accessors
907 // get high part
908 unsigned long GetHi() const { return m_hi; }
909 // get low part
910 unsigned long GetLo() const { return m_lo; }
911
912 // convert to long with range checking in debug mode (only!)
913 unsigned long ToULong() const
914 {
915 wxASSERT_MSG( m_hi == 0ul,
916 wxT("wxULongLong to long conversion loss of precision") );
917
918 return (unsigned long)m_lo;
919 }
920
921 // convert to double
922 double ToDouble() const;
923
924 // operations
925 // addition
926 wxULongLongWx operator+(const wxULongLongWx& ll) const;
927 wxULongLongWx& operator+=(const wxULongLongWx& ll);
928 wxULongLongWx operator+(unsigned long l) const;
929 wxULongLongWx& operator+=(unsigned long l);
930
931 // pre increment operator
932 wxULongLongWx& operator++();
933
934 // post increment operator
935 wxULongLongWx& operator++(int) { return ++(*this); }
936
937 // subtraction
938 wxLongLongWx operator-(const wxULongLongWx& ll) const;
939 wxULongLongWx& operator-=(const wxULongLongWx& ll);
940
941 // pre decrement operator
942 wxULongLongWx& operator--();
943
944 // post decrement operator
945 wxULongLongWx& operator--(int) { return --(*this); }
946
947 // shifts
948 // left shift
949 wxULongLongWx operator<<(int shift) const;
950 wxULongLongWx& operator<<=(int shift);
951
952 // right shift
953 wxULongLongWx operator>>(int shift) const;
954 wxULongLongWx& operator>>=(int shift);
955
956 // bitwise operators
957 wxULongLongWx operator&(const wxULongLongWx& ll) const;
958 wxULongLongWx& operator&=(const wxULongLongWx& ll);
959 wxULongLongWx operator|(const wxULongLongWx& ll) const;
960 wxULongLongWx& operator|=(const wxULongLongWx& ll);
961 wxULongLongWx operator^(const wxULongLongWx& ll) const;
962 wxULongLongWx& operator^=(const wxULongLongWx& ll);
963 wxULongLongWx operator~() const;
964
965 // comparison
966 bool operator==(const wxULongLongWx& ll) const
967 { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
968 bool operator!=(const wxULongLongWx& ll) const
969 { return !(*this == ll); }
970 bool operator<(const wxULongLongWx& ll) const;
971 bool operator>(const wxULongLongWx& ll) const;
972 bool operator<=(const wxULongLongWx& ll) const
973 { return *this < ll || *this == ll; }
974 bool operator>=(const wxULongLongWx& ll) const
975 { return *this > ll || *this == ll; }
976
977 bool operator<(unsigned long l) const { return *this < wxULongLongWx(l); }
978 bool operator>(unsigned long l) const { return *this > wxULongLongWx(l); }
979 bool operator==(unsigned long l) const
980 {
981 return (m_hi == 0 && m_lo == (unsigned long)l);
982 }
983
984 bool operator<=(unsigned long l) const { return *this < l || *this == l; }
985 bool operator>=(unsigned long l) const { return *this > l || *this == l; }
986
987 // multiplication
988 wxULongLongWx operator*(const wxULongLongWx& ll) const;
989 wxULongLongWx& operator*=(const wxULongLongWx& ll);
990
991 // division
992 wxULongLongWx operator/(const wxULongLongWx& ll) const;
993 wxULongLongWx& operator/=(const wxULongLongWx& ll);
994
995 wxULongLongWx operator%(const wxULongLongWx& ll) const;
996
997 void Divide(const wxULongLongWx& divisor,
998 wxULongLongWx& quotient,
999 wxULongLongWx& remainder) const;
1000
1001 // input/output
1002
1003 // return the string representation of this number
1004 wxString ToString() const;
1005
1006 void *asArray() const;
1007
1008 #if wxUSE_STD_IOSTREAM
1009 friend WXDLLIMPEXP_BASE
1010 wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
1011 #endif // wxUSE_STD_IOSTREAM
1012
1013 friend WXDLLIMPEXP_BASE
1014 wxString& operator<<(wxString&, const wxULongLongWx&);
1015
1016 #if wxUSE_STREAMS
1017 friend WXDLLIMPEXP_BASE
1018 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongWx&);
1019 friend WXDLLIMPEXP_BASE
1020 class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongWx&);
1021 #endif
1022
1023 private:
1024 // long is at least 32 bits, so represent our 64bit number as 2 longs
1025
1026 unsigned long m_hi;
1027 unsigned long m_lo;
1028
1029 #ifdef wxLONGLONG_TEST_MODE
1030 void Check()
1031 {
1032 wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
1033 }
1034
1035 wxULongLong_t m_ll;
1036 #endif // wxLONGLONG_TEST_MODE
1037 };
1038
1039 #endif // wxUSE_LONGLONG_WX
1040
1041 // ----------------------------------------------------------------------------
1042 // binary operators
1043 // ----------------------------------------------------------------------------
1044
1045 inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
1046 inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
1047 inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
1048 inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
1049 inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
1050 inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }
1051
1052 inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }
1053 inline wxLongLong operator-(long l, const wxLongLong& ll)
1054 {
1055 return wxLongLong(l) - ll;
1056 }
1057
1058 inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
1059 inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
1060 inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
1061 inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
1062 inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
1063 inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }
1064
1065 inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
1066
1067 inline wxLongLong operator-(unsigned long l, const wxULongLong& ull)
1068 {
1069 wxULongLong ret = wxULongLong(l) - ull;
1070 return wxLongLong((long)ret.GetHi(),ret.GetLo());
1071 }
1072
1073 #if wxUSE_LONGLONG_NATIVE && wxUSE_STREAMS
1074
1075 WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxULongLong_t value);
1076 WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxLongLong_t value);
1077
1078 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxULongLong_t &value);
1079 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxLongLong_t &value);
1080
1081 #endif
1082
1083 // ----------------------------------------------------------------------------
1084 // Specialize numeric_limits<> for our long long wrapper classes.
1085 // ----------------------------------------------------------------------------
1086
1087 #if wxUSE_LONGLONG_NATIVE
1088
1089 // VC6 is known to not have __int64 specializations of numeric_limits<> in its
1090 // <limits> anyhow so don't bother including it, especially as it results in
1091 // tons of warnings because the standard header itself uses obsolete template
1092 // specialization syntax.
1093 #ifndef __VISUALC6__
1094
1095 #include <limits>
1096
1097 namespace std
1098 {
1099
1100 #ifdef __clang__
1101 // libstdc++ (used by Clang) uses struct for numeric_limits; unlike gcc, clang
1102 // warns about this
1103 template<> struct numeric_limits<wxLongLong> : public numeric_limits<wxLongLong_t> {};
1104 template<> struct numeric_limits<wxULongLong> : public numeric_limits<wxULongLong_t> {};
1105 #else
1106 template<> class numeric_limits<wxLongLong> : public numeric_limits<wxLongLong_t> {};
1107 template<> class numeric_limits<wxULongLong> : public numeric_limits<wxULongLong_t> {};
1108 #endif
1109
1110 } // namespace std
1111
1112 #endif // !VC6
1113
1114 #endif // wxUSE_LONGLONG_NATIVE
1115
1116 // ----------------------------------------------------------------------------
1117 // Specialize wxArgNormalizer to allow using wxLongLong directly with wx pseudo
1118 // vararg functions.
1119 // ----------------------------------------------------------------------------
1120
1121 // Notice that this must be done here and not in wx/strvararg.h itself because
1122 // we can't include wx/longlong.h from there as this header itself includes
1123 // wx/string.h which includes wx/strvararg.h too, so to avoid the circular
1124 // dependencies we can only do it here (or add another header just for this but
1125 // it doesn't seem necessary).
1126 #include "wx/strvararg.h"
1127
1128 template<>
1129 struct WXDLLIMPEXP_BASE wxArgNormalizer<wxLongLong>
1130 {
1131 wxArgNormalizer(wxLongLong value,
1132 const wxFormatString *fmt, unsigned index)
1133 : m_value(value)
1134 {
1135 wxASSERT_ARG_TYPE( fmt, index, wxFormatString::Arg_LongLongInt );
1136 }
1137
1138 wxLongLong_t get() const { return m_value.GetValue(); }
1139
1140 wxLongLong m_value;
1141 };
1142
1143 #endif // wxUSE_LONGLONG
1144
1145 #endif // _WX_LONGLONG_H
wxWidgets (Impactor)