]> 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
fix monodll build
[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 #if defined(__GNUG__) && !defined(__APPLE__)
17 #pragma interface "longlong.h"
18 #endif
19
20 #include "wx/defs.h"
21 #include "wx/string.h"
22
23 #include <limits.h> // for LONG_MAX
24
25 // define this to compile wxLongLongWx in "test" mode: the results of all
26 // calculations will be compared with the real results taken from
27 // wxLongLongNative -- this is extremely useful to find the bugs in
28 // wxLongLongWx class!
29
30 // #define wxLONGLONG_TEST_MODE
31
32 #ifdef wxLONGLONG_TEST_MODE
33 #define wxUSE_LONGLONG_WX 1
34 #define wxUSE_LONGLONG_NATIVE 1
35 #endif // wxLONGLONG_TEST_MODE
36
37 // ----------------------------------------------------------------------------
38 // decide upon which class we will use
39 // ----------------------------------------------------------------------------
40
41 // to avoid compilation problems on 64bit machines with ambiguous method calls
42 // we will need to define this
43 #undef wxLongLongIsLong
44
45 // NB: we #define and not typedef wxLongLong_t because we want to be able to
46 // use 'unsigned wxLongLong_t' as well and because we use "#ifdef
47 // wxLongLong_t" below
48
49 // first check for generic cases which are long on 64bit machine and "long
50 // long", then check for specific compilers
51 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
52 #define wxLongLong_t long
53 #define wxLongLongSuffix l
54 #define wxLongLongFmtSpec _T("l")
55 #define wxLongLongIsLong
56 #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
57 #define wxLongLong_t __int64
58 #define wxLongLongSuffix i64
59 #define wxLongLongFmtSpec _T("I64")
60 #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
61 #define wxLongLong_t __int64
62 #define wxLongLongSuffix i64
63 #define wxLongLongFmtSpec _T("Ld")
64 #elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8) || \
65 defined(__MINGW32__) || \
66 defined(__GNUC__) || \
67 defined(__CYGWIN__) || \
68 defined(__WXMICROWIN__) || \
69 (defined(__DJGPP__) && __DJGPP__ >= 2)
70 #define wxLongLong_t long long
71 #define wxLongLongSuffix ll
72 #define wxLongLongFmtSpec _T("ll")
73 #elif defined(__MWERKS__)
74 #if __option(longlong)
75 #define wxLongLong_t long long
76 #define wxLongLongSuffix ll
77 #define wxLongLongFmtSpec _T("ll")
78 #else
79 #error "The 64 bit integer support in CodeWarrior has been disabled."
80 #error "See the documentation on the 'longlong' pragma."
81 #endif
82 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
83 #define wxLongLong_t long long
84 #else // no native long long type
85 // both warning and pragma warning are not portable, but at least an
86 // unknown pragma should never be an error -- except that, actually, some
87 // broken compilers don't like it, so we have to disable it in this case
88 // <sigh>
89 #if !(defined(__WATCOMC__) || defined(__VISAGECPP__))
90 #pragma warning "Your compiler does not appear to support 64 bit "\
91 "integers, using emulation class instead.\n" \
92 "Please report your compiler version to " \
93 "wx-dev@lists.wxwindows.org!"
94 #endif
95
96 #define wxUSE_LONGLONG_WX 1
97 #endif // compiler
98
99 // this macro allows to definea 64 bit constant in a portable way
100 #define wxMakeLongLong(x, s) x ## s
101 #define wxMakeLongLong2(x, s) wxMakeLongLong(x, s)
102 #define wxLL(x) wxMakeLongLong2(x, wxLongLongSuffix)
103
104 // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
105 // to disable automatic testing (useful for the test program which defines
106 // both classes) but by default we only use one class
107 #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
108 // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set:
109 // this is useful in test programs and only there
110 #ifndef wxUSE_LONGLONG_NATIVE
111 #define wxUSE_LONGLONG_NATIVE 0
112 #endif
113
114 class WXDLLIMPEXP_BASE wxLongLongWx;
115 class WXDLLIMPEXP_BASE wxULongLongWx;
116 #if defined(__VISUALC__) && !defined(__WIN32__)
117 #define wxLongLong wxLongLongWx
118 #define wxULongLong wxULongLongWx
119 #else
120 typedef wxLongLongWx wxLongLong;
121 typedef wxULongLongWx wxULongLong;
122 #endif
123
124 #else
125 // if nothing is defined, use native implementation by default, of course
126 #ifndef wxUSE_LONGLONG_NATIVE
127 #define wxUSE_LONGLONG_NATIVE 1
128 #endif
129 #endif
130
131 #ifndef wxUSE_LONGLONG_WX
132 #define wxUSE_LONGLONG_WX 0
133 class WXDLLIMPEXP_BASE wxLongLongNative;
134 class WXDLLIMPEXP_BASE wxULongLongNative;
135 typedef wxLongLongNative wxLongLong;
136 typedef wxULongLongNative wxULongLong;
137 #endif
138
139 // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should
140 // typedef wxLongLong as it wants, we don't do it
141
142 // ----------------------------------------------------------------------------
143 // choose the appropriate class
144 // ----------------------------------------------------------------------------
145
146 // we use iostream for wxLongLong output
147 #include "wx/iosfwrap.h"
148
149 #if wxUSE_LONGLONG_NATIVE
150
151 class WXDLLIMPEXP_BASE wxLongLongNative
152 {
153 public:
154 // ctors
155 // default ctor initializes to 0
156 wxLongLongNative() : m_ll(0) { }
157 // from long long
158 wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }
159 // from 2 longs
160 wxLongLongNative(long hi, unsigned long lo) : m_ll(0)
161 {
162 // assign first to avoid precision loss!
163 m_ll = ((wxLongLong_t) hi) << 32;
164 m_ll |= (wxLongLong_t) lo;
165 }
166
167 // default copy ctor is ok
168
169 // no dtor
170
171 // assignment operators
172 // from native 64 bit integer
173 wxLongLongNative& operator=(wxLongLong_t ll)
174 { m_ll = ll; return *this; }
175
176 // from double: this one has an explicit name because otherwise we
177 // would have ambiguity with "ll = int" and also because we don't want
178 // to have implicit conversions between doubles and wxLongLongs
179 wxLongLongNative& Assign(double d)
180 { m_ll = (wxLongLong_t)d; return *this; }
181
182 // assignment operators from wxLongLongNative is ok
183
184 // accessors
185 // get high part
186 long GetHi() const
187 { return (long)(m_ll >> 32); }
188 // get low part
189 unsigned long GetLo() const
190 { return (unsigned long)m_ll; }
191
192 // get absolute value
193 wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
194 wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
195
196 // convert to native long long
197 wxLongLong_t GetValue() const { return m_ll; }
198
199 // convert to long with range checking in the debug mode (only!)
200 long ToLong() const
201 {
202 wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
203 _T("wxLongLong to long conversion loss of precision") );
204
205 return (long)m_ll;
206 }
207
208 // don't provide implicit conversion to wxLongLong_t or we will have an
209 // ambiguity for all arithmetic operations
210 //operator wxLongLong_t() const { return m_ll; }
211
212 // operations
213 // addition
214 wxLongLongNative operator+(const wxLongLongNative& ll) const
215 { return wxLongLongNative(m_ll + ll.m_ll); }
216 wxLongLongNative& operator+=(const wxLongLongNative& ll)
217 { m_ll += ll.m_ll; return *this; }
218
219 wxLongLongNative operator+(const wxLongLong_t ll) const
220 { return wxLongLongNative(m_ll + ll); }
221 wxLongLongNative& operator+=(const wxLongLong_t ll)
222 { m_ll += ll; return *this; }
223
224 // pre increment
225 wxLongLongNative& operator++()
226 { m_ll++; return *this; }
227
228 // post increment
229 wxLongLongNative operator++(int)
230 { wxLongLongNative value(*this); m_ll++; return value; }
231
232 // negation operator
233 wxLongLongNative operator-() const
234 { return wxLongLongNative(-m_ll); }
235 wxLongLongNative& Negate() { m_ll = -m_ll; return *this; }
236
237 // subtraction
238 wxLongLongNative operator-(const wxLongLongNative& ll) const
239 { return wxLongLongNative(m_ll - ll.m_ll); }
240 wxLongLongNative& operator-=(const wxLongLongNative& ll)
241 { m_ll -= ll.m_ll; return *this; }
242
243 wxLongLongNative operator-(const wxLongLong_t ll) const
244 { return wxLongLongNative(m_ll - ll); }
245 wxLongLongNative& operator-=(const wxLongLong_t ll)
246 { m_ll -= ll; return *this; }
247
248 // pre decrement
249 wxLongLongNative& operator--()
250 { m_ll--; return *this; }
251
252 // post decrement
253 wxLongLongNative operator--(int)
254 { wxLongLongNative value(*this); m_ll--; return value; }
255
256 // shifts
257 // left shift
258 wxLongLongNative operator<<(int shift) const
259 { return wxLongLongNative(m_ll << shift);; }
260 wxLongLongNative& operator<<=(int shift)
261 { m_ll <<= shift; return *this; }
262
263 // right shift
264 wxLongLongNative operator>>(int shift) const
265 { return wxLongLongNative(m_ll >> shift);; }
266 wxLongLongNative& operator>>=(int shift)
267 { m_ll >>= shift; return *this; }
268
269 // bitwise operators
270 wxLongLongNative operator&(const wxLongLongNative& ll) const
271 { return wxLongLongNative(m_ll & ll.m_ll); }
272 wxLongLongNative& operator&=(const wxLongLongNative& ll)
273 { m_ll &= ll.m_ll; return *this; }
274
275 wxLongLongNative operator|(const wxLongLongNative& ll) const
276 { return wxLongLongNative(m_ll | ll.m_ll); }
277 wxLongLongNative& operator|=(const wxLongLongNative& ll)
278 { m_ll |= ll.m_ll; return *this; }
279
280 wxLongLongNative operator^(const wxLongLongNative& ll) const
281 { return wxLongLongNative(m_ll ^ ll.m_ll); }
282 wxLongLongNative& operator^=(const wxLongLongNative& ll)
283 { m_ll ^= ll.m_ll; return *this; }
284
285 // multiplication/division
286 wxLongLongNative operator*(const wxLongLongNative& ll) const
287 { return wxLongLongNative(m_ll * ll.m_ll); }
288 wxLongLongNative operator*(long l) const
289 { return wxLongLongNative(m_ll * l); }
290 wxLongLongNative& operator*=(const wxLongLongNative& ll)
291 { m_ll *= ll.m_ll; return *this; }
292 wxLongLongNative& operator*=(long l)
293 { m_ll *= l; return *this; }
294
295 wxLongLongNative operator/(const wxLongLongNative& ll) const
296 { return wxLongLongNative(m_ll / ll.m_ll); }
297 wxLongLongNative operator/(long l) const
298 { return wxLongLongNative(m_ll / l); }
299 wxLongLongNative& operator/=(const wxLongLongNative& ll)
300 { m_ll /= ll.m_ll; return *this; }
301 wxLongLongNative& operator/=(long l)
302 { m_ll /= l; return *this; }
303
304 wxLongLongNative operator%(const wxLongLongNative& ll) const
305 { return wxLongLongNative(m_ll % ll.m_ll); }
306 wxLongLongNative operator%(long l) const
307 { return wxLongLongNative(m_ll % l); }
308
309 // comparison
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 bool operator!=(const wxLongLongNative& ll) const
315 { return m_ll != ll.m_ll; }
316 bool operator!=(long l) const
317 { return m_ll != l; }
318 bool operator<(const wxLongLongNative& ll) const
319 { return m_ll < ll.m_ll; }
320 bool operator<(long l) const
321 { return m_ll < l; }
322 bool operator>(const wxLongLongNative& ll) const
323 { return m_ll > ll.m_ll; }
324 bool operator>(long l) const
325 { return m_ll > l; }
326 bool operator<=(const wxLongLongNative& ll) const
327 { return m_ll <= ll.m_ll; }
328 bool operator<=(long l) const
329 { return m_ll <= l; }
330 bool operator>=(const wxLongLongNative& ll) const
331 { return m_ll >= ll.m_ll; }
332 bool operator>=(long l) const
333 { return m_ll >= l; }
334
335 // miscellaneous
336
337 // return the string representation of this number
338 wxString ToString() const;
339
340 // conversion to byte array: returns a pointer to static buffer!
341 void *asArray() const;
342
343 #if wxUSE_STD_IOSTREAM
344 // input/output
345 friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
346 #endif
347
348 private:
349 wxLongLong_t m_ll;
350 };
351
352
353 class WXDLLIMPEXP_BASE wxULongLongNative
354 {
355 public:
356 // ctors
357 // default ctor initializes to 0
358 wxULongLongNative() : m_ll(0) { }
359 // from long long
360 wxULongLongNative(unsigned wxLongLong_t ll) : m_ll(ll) { }
361 // from 2 longs
362 wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)
363 {
364 // assign first to avoid precision loss!
365 m_ll = ((unsigned wxLongLong_t) hi) << 32;
366 m_ll |= (unsigned wxLongLong_t) lo;
367 }
368
369 // default copy ctor is ok
370
371 // no dtor
372
373 // assignment operators
374 // from native 64 bit integer
375 wxULongLongNative& operator=(unsigned wxLongLong_t ll)
376 { m_ll = ll; return *this; }
377
378 // assignment operators from wxULongLongNative is ok
379
380 // accessors
381 // get high part
382 unsigned long GetHi() const
383 { return (unsigned long)(m_ll >> 32); }
384 // get low part
385 unsigned long GetLo() const
386 { return (unsigned long)m_ll; }
387
388 // convert to native ulong long
389 unsigned wxLongLong_t GetValue() const { return m_ll; }
390
391 // convert to ulong with range checking in the debug mode (only!)
392 unsigned long ToULong() const
393 {
394 wxASSERT_MSG( m_ll <= LONG_MAX,
395 _T("wxULongLong to long conversion loss of precision") );
396
397 return (unsigned long)m_ll;
398 }
399
400 // operations
401 // addition
402 wxULongLongNative operator+(const wxULongLongNative& ll) const
403 { return wxULongLongNative(m_ll + ll.m_ll); }
404 wxULongLongNative& operator+=(const wxULongLongNative& ll)
405 { m_ll += ll.m_ll; return *this; }
406
407 wxULongLongNative operator+(const unsigned wxLongLong_t ll) const
408 { return wxULongLongNative(m_ll + ll); }
409 wxULongLongNative& operator+=(const unsigned wxLongLong_t ll)
410 { m_ll += ll; return *this; }
411
412 // pre increment
413 wxULongLongNative& operator++()
414 { m_ll++; return *this; }
415
416 // post increment
417 wxULongLongNative operator++(int)
418 { wxULongLongNative value(*this); m_ll++; return value; }
419
420 // subtraction
421 wxULongLongNative operator-(const wxULongLongNative& ll) const
422 { return wxULongLongNative(m_ll - ll.m_ll); }
423 wxULongLongNative& operator-=(const wxULongLongNative& ll)
424 { m_ll -= ll.m_ll; return *this; }
425
426 wxULongLongNative operator-(const unsigned wxLongLong_t ll) const
427 { return wxULongLongNative(m_ll - ll); }
428 wxULongLongNative& operator-=(const unsigned wxLongLong_t ll)
429 { m_ll -= ll; return *this; }
430
431 // pre decrement
432 wxULongLongNative& operator--()
433 { m_ll--; return *this; }
434
435 // post decrement
436 wxULongLongNative operator--(int)
437 { wxULongLongNative value(*this); m_ll--; return value; }
438
439 // shifts
440 // left shift
441 wxULongLongNative operator<<(int shift) const
442 { return wxULongLongNative(m_ll << shift);; }
443 wxULongLongNative& operator<<=(int shift)
444 { m_ll <<= shift; return *this; }
445
446 // right shift
447 wxULongLongNative operator>>(int shift) const
448 { return wxULongLongNative(m_ll >> shift);; }
449 wxULongLongNative& operator>>=(int shift)
450 { m_ll >>= shift; return *this; }
451
452 // bitwise operators
453 wxULongLongNative operator&(const wxULongLongNative& ll) const
454 { return wxULongLongNative(m_ll & ll.m_ll); }
455 wxULongLongNative& operator&=(const wxULongLongNative& ll)
456 { m_ll &= ll.m_ll; return *this; }
457
458 wxULongLongNative operator|(const wxULongLongNative& ll) const
459 { return wxULongLongNative(m_ll | ll.m_ll); }
460 wxULongLongNative& operator|=(const wxULongLongNative& ll)
461 { m_ll |= ll.m_ll; return *this; }
462
463 wxULongLongNative operator^(const wxULongLongNative& ll) const
464 { return wxULongLongNative(m_ll ^ ll.m_ll); }
465 wxULongLongNative& operator^=(const wxULongLongNative& ll)
466 { m_ll ^= ll.m_ll; return *this; }
467
468 // multiplication/division
469 wxULongLongNative operator*(const wxULongLongNative& ll) const
470 { return wxULongLongNative(m_ll * ll.m_ll); }
471 wxULongLongNative operator*(unsigned long l) const
472 { return wxULongLongNative(m_ll * l); }
473 wxULongLongNative& operator*=(const wxULongLongNative& ll)
474 { m_ll *= ll.m_ll; return *this; }
475 wxULongLongNative& operator*=(unsigned long l)
476 { m_ll *= l; return *this; }
477
478 wxULongLongNative operator/(const wxULongLongNative& ll) const
479 { return wxULongLongNative(m_ll / ll.m_ll); }
480 wxULongLongNative operator/(unsigned long l) const
481 { return wxULongLongNative(m_ll / l); }
482 wxULongLongNative& operator/=(const wxULongLongNative& ll)
483 { m_ll /= ll.m_ll; return *this; }
484 wxULongLongNative& operator/=(unsigned long l)
485 { m_ll /= l; return *this; }
486
487 wxULongLongNative operator%(const wxULongLongNative& ll) const
488 { return wxULongLongNative(m_ll % ll.m_ll); }
489 wxULongLongNative operator%(unsigned long l) const
490 { return wxULongLongNative(m_ll % l); }
491
492 // comparison
493 bool operator==(const wxULongLongNative& ll) const
494 { return m_ll == ll.m_ll; }
495 bool operator==(unsigned long l) const
496 { return m_ll == l; }
497 bool operator!=(const wxULongLongNative& ll) const
498 { return m_ll != ll.m_ll; }
499 bool operator!=(unsigned long l) const
500 { return m_ll != l; }
501 bool operator<(const wxULongLongNative& ll) const
502 { return m_ll < ll.m_ll; }
503 bool operator<(unsigned long l) const
504 { return m_ll < l; }
505 bool operator>(const wxULongLongNative& ll) const
506 { return m_ll > ll.m_ll; }
507 bool operator>(unsigned long l) const
508 { return m_ll > l; }
509 bool operator<=(const wxULongLongNative& ll) const
510 { return m_ll <= ll.m_ll; }
511 bool operator<=(unsigned long l) const
512 { return m_ll <= l; }
513 bool operator>=(const wxULongLongNative& ll) const
514 { return m_ll >= ll.m_ll; }
515 bool operator>=(unsigned long l) const
516 { return m_ll >= l; }
517
518 // miscellaneous
519
520 // return the string representation of this number
521 wxString ToString() const;
522
523 // conversion to byte array: returns a pointer to static buffer!
524 void *asArray() const;
525
526 #if wxUSE_STD_IOSTREAM
527 // input/output
528 friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
529 #endif
530
531 private:
532 unsigned wxLongLong_t m_ll;
533 };
534
535 #endif // wxUSE_LONGLONG_NATIVE
536
537 #if wxUSE_LONGLONG_WX
538
539 class WXDLLIMPEXP_BASE wxLongLongWx
540 {
541 public:
542 // ctors
543 // default ctor initializes to 0
544 wxLongLongWx()
545 {
546 m_lo = m_hi = 0;
547
548 #ifdef wxLONGLONG_TEST_MODE
549 m_ll = 0;
550
551 Check();
552 #endif // wxLONGLONG_TEST_MODE
553 }
554 // from long
555 wxLongLongWx(long l) { *this = l; }
556 // from 2 longs
557 wxLongLongWx(long hi, unsigned long lo)
558 {
559 m_hi = hi;
560 m_lo = lo;
561
562 #ifdef wxLONGLONG_TEST_MODE
563 m_ll = hi;
564 m_ll <<= 32;
565 m_ll |= lo;
566
567 Check();
568 #endif // wxLONGLONG_TEST_MODE
569 }
570
571 // default copy ctor is ok in both cases
572
573 // no dtor
574
575 // assignment operators
576 // from long
577 wxLongLongWx& operator=(long l)
578 {
579 m_lo = l;
580 m_hi = (l < 0 ? -1l : 0l);
581
582 #ifdef wxLONGLONG_TEST_MODE
583 m_ll = l;
584
585 Check();
586 #endif // wxLONGLONG_TEST_MODE
587
588 return *this;
589 }
590 // from double
591 wxLongLongWx& Assign(double d);
592 // can't have assignment operator from 2 longs
593
594 // accessors
595 // get high part
596 long GetHi() const { return m_hi; }
597 // get low part
598 unsigned long GetLo() const { return m_lo; }
599
600 // get absolute value
601 wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
602 wxLongLongWx& Abs()
603 {
604 if ( m_hi < 0 )
605 m_hi = -m_hi;
606
607 #ifdef wxLONGLONG_TEST_MODE
608 if ( m_ll < 0 )
609 m_ll = -m_ll;
610
611 Check();
612 #endif // wxLONGLONG_TEST_MODE
613
614 return *this;
615 }
616
617 // convert to long with range checking in the debug mode (only!)
618 long ToLong() const
619 {
620 wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l),
621 _T("wxLongLong to long conversion loss of precision") );
622
623 return (long)m_lo;
624 }
625
626 // operations
627 // addition
628 wxLongLongWx operator+(const wxLongLongWx& ll) const;
629 wxLongLongWx& operator+=(const wxLongLongWx& ll);
630 wxLongLongWx operator+(long l) const;
631 wxLongLongWx& operator+=(long l);
632
633 // pre increment operator
634 wxLongLongWx& operator++();
635
636 // post increment operator
637 wxLongLongWx& operator++(int) { return ++(*this); }
638
639 // negation operator
640 wxLongLongWx operator-() const;
641 wxLongLongWx& Negate();
642
643 // subraction
644 wxLongLongWx operator-(const wxLongLongWx& ll) const;
645 wxLongLongWx& operator-=(const wxLongLongWx& ll);
646
647 // pre decrement operator
648 wxLongLongWx& operator--();
649
650 // post decrement operator
651 wxLongLongWx& operator--(int) { return --(*this); }
652
653 // shifts
654 // left shift
655 wxLongLongWx operator<<(int shift) const;
656 wxLongLongWx& operator<<=(int shift);
657
658 // right shift
659 wxLongLongWx operator>>(int shift) const;
660 wxLongLongWx& operator>>=(int shift);
661
662 // bitwise operators
663 wxLongLongWx operator&(const wxLongLongWx& ll) const;
664 wxLongLongWx& operator&=(const wxLongLongWx& ll);
665 wxLongLongWx operator|(const wxLongLongWx& ll) const;
666 wxLongLongWx& operator|=(const wxLongLongWx& ll);
667 wxLongLongWx operator^(const wxLongLongWx& ll) const;
668 wxLongLongWx& operator^=(const wxLongLongWx& ll);
669 wxLongLongWx operator~() const;
670
671 // comparison
672 bool operator==(const wxLongLongWx& ll) const
673 { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
674 bool operator!=(const wxLongLongWx& ll) const
675 { return !(*this == ll); }
676 bool operator<(const wxLongLongWx& ll) const;
677 bool operator>(const wxLongLongWx& ll) const;
678 bool operator<=(const wxLongLongWx& ll) const
679 { return *this < ll || *this == ll; }
680 bool operator>=(const wxLongLongWx& ll) const
681 { return *this > ll || *this == ll; }
682
683 bool operator<(long l) const { return *this < wxLongLongWx(l); }
684 bool operator>(long l) const { return *this > wxLongLongWx(l); }
685 bool operator==(long l) const
686 {
687 return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l)
688 : (m_hi == -1 && m_lo == (unsigned long)l);
689 }
690
691 bool operator<=(long l) const { return *this < l || *this == l; }
692 bool operator>=(long l) const { return *this > l || *this == l; }
693
694 // multiplication
695 wxLongLongWx operator*(const wxLongLongWx& ll) const;
696 wxLongLongWx& operator*=(const wxLongLongWx& ll);
697
698 // division
699 wxLongLongWx operator/(const wxLongLongWx& ll) const;
700 wxLongLongWx& operator/=(const wxLongLongWx& ll);
701
702 wxLongLongWx operator%(const wxLongLongWx& ll) const;
703
704 void Divide(const wxLongLongWx& divisor,
705 wxLongLongWx& quotient,
706 wxLongLongWx& remainder) const;
707
708 // input/output
709
710 // return the string representation of this number
711 wxString ToString() const;
712
713 void *asArray() const;
714
715 #if wxUSE_STD_IOSTREAM
716 friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
717 #endif // wxUSE_STD_IOSTREAM
718
719 private:
720 // long is at least 32 bits, so represent our 64bit number as 2 longs
721
722 long m_hi; // signed bit is in the high part
723 unsigned long m_lo;
724
725 #ifdef wxLONGLONG_TEST_MODE
726 void Check()
727 {
728 wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
729 }
730
731 wxLongLong_t m_ll;
732 #endif // wxLONGLONG_TEST_MODE
733 };
734
735
736 class WXDLLIMPEXP_BASE wxULongLongWx
737 {
738 public:
739 // ctors
740 // default ctor initializes to 0
741 wxULongLongWx()
742 {
743 m_lo = m_hi = 0;
744
745 #ifdef wxLONGLONG_TEST_MODE
746 m_ll = 0;
747
748 Check();
749 #endif // wxLONGLONG_TEST_MODE
750 }
751 // from ulong
752 wxULongLongWx(unsigned long l) { *this = l; }
753 // from 2 ulongs
754 wxULongLongWx(unsigned long hi, unsigned long lo)
755 {
756 m_hi = hi;
757 m_lo = lo;
758
759 #ifdef wxLONGLONG_TEST_MODE
760 m_ll = hi;
761 m_ll <<= 32;
762 m_ll |= lo;
763
764 Check();
765 #endif // wxLONGLONG_TEST_MODE
766 }
767
768 // default copy ctor is ok in both cases
769
770 // no dtor
771
772 // assignment operators
773 // from long
774 wxULongLongWx& operator=(unsigned long l)
775 {
776 m_lo = l;
777 m_hi = 0;
778
779 #ifdef wxLONGLONG_TEST_MODE
780 m_ll = l;
781
782 Check();
783 #endif // wxLONGLONG_TEST_MODE
784
785 return *this;
786 }
787
788 // can't have assignment operator from 2 longs
789
790 // accessors
791 // get high part
792 unsigned long GetHi() const { return m_hi; }
793 // get low part
794 unsigned long GetLo() const { return m_lo; }
795
796 // convert to long with range checking in the debug mode (only!)
797 unsigned long ToULong() const
798 {
799 wxASSERT_MSG( m_hi == 0ul,
800 _T("wxULongLong to long conversion loss of precision") );
801
802 return (unsigned long)m_lo;
803 }
804
805 // operations
806 // addition
807 wxULongLongWx operator+(const wxULongLongWx& ll) const;
808 wxULongLongWx& operator+=(const wxULongLongWx& ll);
809 wxULongLongWx operator+(unsigned long l) const;
810 wxULongLongWx& operator+=(unsigned long l);
811
812 // pre increment operator
813 wxULongLongWx& operator++();
814
815 // post increment operator
816 wxULongLongWx& operator++(int) { return ++(*this); }
817
818 // subraction (FIXME: should return wxLongLong)
819 wxULongLongWx operator-(const wxULongLongWx& ll) const;
820 wxULongLongWx& operator-=(const wxULongLongWx& ll);
821
822 // pre decrement operator
823 wxULongLongWx& operator--();
824
825 // post decrement operator
826 wxULongLongWx& operator--(int) { return --(*this); }
827
828 // shifts
829 // left shift
830 wxULongLongWx operator<<(int shift) const;
831 wxULongLongWx& operator<<=(int shift);
832
833 // right shift
834 wxULongLongWx operator>>(int shift) const;
835 wxULongLongWx& operator>>=(int shift);
836
837 // bitwise operators
838 wxULongLongWx operator&(const wxULongLongWx& ll) const;
839 wxULongLongWx& operator&=(const wxULongLongWx& ll);
840 wxULongLongWx operator|(const wxULongLongWx& ll) const;
841 wxULongLongWx& operator|=(const wxULongLongWx& ll);
842 wxULongLongWx operator^(const wxULongLongWx& ll) const;
843 wxULongLongWx& operator^=(const wxULongLongWx& ll);
844 wxULongLongWx operator~() const;
845
846 // comparison
847 bool operator==(const wxULongLongWx& ll) const
848 { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
849 bool operator!=(const wxULongLongWx& ll) const
850 { return !(*this == ll); }
851 bool operator<(const wxULongLongWx& ll) const;
852 bool operator>(const wxULongLongWx& ll) const;
853 bool operator<=(const wxULongLongWx& ll) const
854 { return *this < ll || *this == ll; }
855 bool operator>=(const wxULongLongWx& ll) const
856 { return *this > ll || *this == ll; }
857
858 bool operator<(unsigned long l) const { return *this < wxULongLongWx(l); }
859 bool operator>(unsigned long l) const { return *this > wxULongLongWx(l); }
860 bool operator==(unsigned long l) const
861 {
862 return (m_hi == 0 && m_lo == (unsigned long)l);
863 }
864
865 bool operator<=(unsigned long l) const { return *this < l || *this == l; }
866 bool operator>=(unsigned long l) const { return *this > l || *this == l; }
867
868 // multiplication
869 wxULongLongWx operator*(const wxULongLongWx& ll) const;
870 wxULongLongWx& operator*=(const wxULongLongWx& ll);
871
872 // division
873 wxULongLongWx operator/(const wxULongLongWx& ll) const;
874 wxULongLongWx& operator/=(const wxULongLongWx& ll);
875
876 wxULongLongWx operator%(const wxULongLongWx& ll) const;
877
878 void Divide(const wxULongLongWx& divisor,
879 wxULongLongWx& quotient,
880 wxULongLongWx& remainder) const;
881
882 // input/output
883
884 // return the string representation of this number
885 wxString ToString() const;
886
887 void *asArray() const;
888
889 #if wxUSE_STD_IOSTREAM
890 friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
891 #endif // wxUSE_STD_IOSTREAM
892
893 private:
894 // long is at least 32 bits, so represent our 64bit number as 2 longs
895
896 unsigned long m_hi;
897 unsigned long m_lo;
898
899 #ifdef wxLONGLONG_TEST_MODE
900 void Check()
901 {
902 wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
903 }
904
905 unsigned wxLongLong_t m_ll;
906 #endif // wxLONGLONG_TEST_MODE
907 };
908
909 #endif // wxUSE_LONGLONG_WX
910
911 // ----------------------------------------------------------------------------
912 // binary operators
913 // ----------------------------------------------------------------------------
914
915 inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
916 inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
917 inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
918 inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
919 inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
920 inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }
921
922 inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }
923 inline wxLongLong operator-(long l, const wxLongLong& ll)
924 {
925 return wxLongLong(l) - ll;
926 }
927
928 inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
929 inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
930 inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
931 inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
932 inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
933 inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }
934
935 inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
936
937 // FIXME: this should return wxLongLong
938 inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
939 {
940 return wxULongLong(l) - ull;
941 }
942
943 #endif // _WX_LONGLONG_H
wxWidgets (Impactor)