← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to include/wx/longlong.h

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

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