X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/617ec45690c340d059726a09ccfe4bab9a42d82e..50ccc908dc4e6376de91edd7f74018898fd690b1:/include/wx/longlong.h diff --git a/include/wx/longlong.h b/include/wx/longlong.h index 5ff8a9b01c..e05287c965 100644 --- a/include/wx/longlong.h +++ b/include/wx/longlong.h @@ -3,25 +3,21 @@ // Purpose: declaration of wxLongLong class - best implementation of a 64 // bit integer for the current platform. // Author: Jeffrey C. Ollie , Vadim Zeitlin -// Remarks: this class is not public in wxWindows 2.0! It is intentionally -// not documented and is for private use only. // Modified by: // Created: 10.02.99 // RCS-ID: $Id$ // Copyright: (c) 1998 Vadim Zeitlin -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_LONGLONG_H #define _WX_LONGLONG_H -#ifdef __GNUG__ - #pragma interface "longlong.h" -#endif - #include "wx/defs.h" -#include "wx/wxchar.h" -#include "wx/debug.h" + +#if wxUSE_LONGLONG + +#include "wx/string.h" #include // for LONG_MAX @@ -30,7 +26,7 @@ // wxLongLongNative -- this is extremely useful to find the bugs in // wxLongLongWx class! -//#define wxLONGLONG_TEST_MODE +// #define wxLONGLONG_TEST_MODE #ifdef wxLONGLONG_TEST_MODE #define wxUSE_LONGLONG_WX 1 @@ -41,40 +37,22 @@ // decide upon which class we will use // ---------------------------------------------------------------------------- -// to avoid compilation problems on 64bit machines with ambiguous method calls -// we will need to define this -#undef wxLongLongIsLong - -// NB: we #define and not typedef wxLongLong_t because we want to be able to -// use 'unsigned wxLongLong_t' as well and because we use "#ifdef -// wxLongLong_t" below -#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) - #define wxLongLong_t long - #define wxLongLongIsLong -#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ ) - #define wxLongLong_t __int64 -#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x530) - #define wxLongLong_t __int64 -#elif defined(__GNUG__) - #define wxLongLong_t long long -#elif defined(__MWERKS__) - #if __option(longlong) - #define wxLongLong_t long long - #else - #error "The 64 bit integer support in CodeWarrior has been disabled." - #error "See the documentation on the 'longlong' pragma." - #endif -#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400 - #define wxLongLong_t long long -#else // no native long long type +#ifndef wxLongLong_t // both warning and pragma warning are not portable, but at least an - // unknown pragma should never be an error. - // Err, actually, Watcom C++ doesn't like it. - // (well, if the compilers are _that_ broken, I'm removing it (VZ)) -#if 0 //ndef __WATCOMC__ - #pragma warning "Your compiler does not appear to support 64 bit "\ - "integers, using emulation class instead." -#endif + // unknown pragma should never be an error -- except that, actually, some + // broken compilers don't like it, so we have to disable it in this case + // + #ifdef __GNUC__ + #warning "Your compiler does not appear to support 64 bit "\ + "integers, using emulation class instead.\n" \ + "Please report your compiler version to " \ + "wx-dev@lists.wxwidgets.org!" + #elif !(defined(__WATCOMC__) || defined(__VISAGECPP__)) + #pragma warning "Your compiler does not appear to support 64 bit "\ + "integers, using emulation class instead.\n" \ + "Please report your compiler version to " \ + "wx-dev@lists.wxwidgets.org!" + #endif #define wxUSE_LONGLONG_WX 1 #endif // compiler @@ -84,13 +62,21 @@ // both classes) but by default we only use one class #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t) // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set: - // this is useful in test programs nad only there + // this is useful in test programs and only there #ifndef wxUSE_LONGLONG_NATIVE #define wxUSE_LONGLONG_NATIVE 0 #endif - class WXDLLEXPORT wxLongLongWx; + class WXDLLIMPEXP_FWD_BASE wxLongLongWx; + class WXDLLIMPEXP_FWD_BASE wxULongLongWx; +#if defined(__VISUALC__) && !defined(__WIN32__) + #define wxLongLong wxLongLongWx + #define wxULongLong wxULongLongWx +#else typedef wxLongLongWx wxLongLong; + typedef wxULongLongWx wxULongLong; +#endif + #else // if nothing is defined, use native implementation by default, of course #ifndef wxUSE_LONGLONG_NATIVE @@ -100,8 +86,10 @@ #ifndef wxUSE_LONGLONG_WX #define wxUSE_LONGLONG_WX 0 - class WXDLLEXPORT wxLongLongNative; + class WXDLLIMPEXP_FWD_BASE wxLongLongNative; + class WXDLLIMPEXP_FWD_BASE wxULongLongNative; typedef wxLongLongNative wxLongLong; + typedef wxULongLongNative wxULongLong; #endif // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should @@ -112,25 +100,28 @@ // ---------------------------------------------------------------------------- // we use iostream for wxLongLong output -#include "wx/ioswrap.h" +#include "wx/iosfwrap.h" #if wxUSE_LONGLONG_NATIVE -class WXDLLEXPORT wxLongLongNative +class WXDLLIMPEXP_BASE wxLongLongNative { public: // ctors // default ctor initializes to 0 - wxLongLongNative() { m_ll = 0; } + wxLongLongNative() : m_ll(0) { } // from long long - wxLongLongNative(wxLongLong_t ll) { m_ll = ll; } + wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { } // from 2 longs - wxLongLongNative(long hi, unsigned long lo) + wxLongLongNative(wxInt32 hi, wxUint32 lo) { - // assign first to avoid precision loss! + // cast to wxLongLong_t first to avoid precision loss! m_ll = ((wxLongLong_t) hi) << 32; m_ll |= (wxLongLong_t) lo; } +#if wxUSE_LONGLONG_WX + wxLongLongNative(wxLongLongWx ll); +#endif // default copy ctor is ok @@ -138,8 +129,26 @@ public: // assignment operators // from native 64 bit integer +#ifndef wxLongLongIsLong wxLongLongNative& operator=(wxLongLong_t ll) { m_ll = ll; return *this; } + wxLongLongNative& operator=(wxULongLong_t ll) + { m_ll = ll; return *this; } +#endif // !wxLongLongNative + wxLongLongNative& operator=(const wxULongLongNative &ll); + wxLongLongNative& operator=(int l) + { m_ll = l; return *this; } + wxLongLongNative& operator=(long l) + { m_ll = l; return *this; } + wxLongLongNative& operator=(unsigned int l) + { m_ll = l; return *this; } + wxLongLongNative& operator=(unsigned long l) + { m_ll = l; return *this; } +#if wxUSE_LONGLONG_WX + wxLongLongNative& operator=(wxLongLongWx ll); + wxLongLongNative& operator=(const class wxULongLongWx &ll); +#endif + // from double: this one has an explicit name because otherwise we // would have ambiguity with "ll = int" and also because we don't want @@ -151,11 +160,11 @@ public: // accessors // get high part - long GetHi() const - { return (long)(m_ll >> 32); } + wxInt32 GetHi() const + { return wx_truncate_cast(wxInt32, m_ll >> 32); } // get low part - unsigned long GetLo() const - { return (unsigned long)m_ll; } + wxUint32 GetLo() const + { return wx_truncate_cast(wxUint32, m_ll); } // get absolute value wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); } @@ -164,15 +173,18 @@ public: // convert to native long long wxLongLong_t GetValue() const { return m_ll; } - // convert to long with range checking in the debug mode (only!) + // convert to long with range checking in debug mode (only!) long ToLong() const { wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX), _T("wxLongLong to long conversion loss of precision") ); - return (long)m_ll; + return wx_truncate_cast(long, m_ll); } + // convert to double + double ToDouble() const { return wx_truncate_cast(double, m_ll); } + // don't provide implicit conversion to wxLongLong_t or we will have an // ambiguity for all arithmetic operations //operator wxLongLong_t() const { return m_ll; } @@ -194,12 +206,13 @@ public: { m_ll++; return *this; } // post increment - wxLongLongNative& operator++(int) - { m_ll++; return *this; } + wxLongLongNative operator++(int) + { wxLongLongNative value(*this); m_ll++; return value; } // negation operator wxLongLongNative operator-() const { return wxLongLongNative(-m_ll); } + wxLongLongNative& Negate() { m_ll = -m_ll; return *this; } // subtraction wxLongLongNative operator-(const wxLongLongNative& ll) const @@ -217,19 +230,19 @@ public: { m_ll--; return *this; } // post decrement - wxLongLongNative& operator--(int) - { m_ll--; return *this; } + wxLongLongNative operator--(int) + { wxLongLongNative value(*this); m_ll--; return value; } // shifts // left shift wxLongLongNative operator<<(int shift) const - { return wxLongLongNative(m_ll << shift);; } + { return wxLongLongNative(m_ll << shift); } wxLongLongNative& operator<<=(int shift) { m_ll <<= shift; return *this; } // right shift wxLongLongNative operator>>(int shift) const - { return wxLongLongNative(m_ll >> shift);; } + { return wxLongLongNative(m_ll >> shift); } wxLongLongNative& operator>>=(int shift) { m_ll >>= shift; return *this; } @@ -300,23 +313,268 @@ public: { return m_ll >= l; } // miscellaneous + + // return the string representation of this number + wxString ToString() const; + // conversion to byte array: returns a pointer to static buffer! void *asArray() const; #if wxUSE_STD_IOSTREAM // input/output - friend ostream& operator<<(ostream&, const wxLongLongNative&); + friend WXDLLIMPEXP_BASE + wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&); +#endif + + friend WXDLLIMPEXP_BASE + wxString& operator<<(wxString&, const wxLongLongNative&); + +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongNative&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongNative&); #endif private: wxLongLong_t m_ll; }; + +class WXDLLIMPEXP_BASE wxULongLongNative +{ +public: + // ctors + // default ctor initializes to 0 + wxULongLongNative() : m_ll(0) { } + // from long long + wxULongLongNative(wxULongLong_t ll) : m_ll(ll) { } + // from 2 longs + wxULongLongNative(wxUint32 hi, wxUint32 lo) : m_ll(0) + { + // cast to wxLongLong_t first to avoid precision loss! + m_ll = ((wxULongLong_t) hi) << 32; + m_ll |= (wxULongLong_t) lo; + } + +#if wxUSE_LONGLONG_WX + wxULongLongNative(const class wxULongLongWx &ll); +#endif + + // default copy ctor is ok + + // no dtor + + // assignment operators + // from native 64 bit integer +#ifndef wxLongLongIsLong + wxULongLongNative& operator=(wxULongLong_t ll) + { m_ll = ll; return *this; } + wxULongLongNative& operator=(wxLongLong_t ll) + { m_ll = ll; return *this; } +#endif // !wxLongLongNative + wxULongLongNative& operator=(int l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(long l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(unsigned int l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(unsigned long l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(const wxLongLongNative &ll) + { m_ll = ll.GetValue(); return *this; } +#if wxUSE_LONGLONG_WX + wxULongLongNative& operator=(wxLongLongWx ll); + wxULongLongNative& operator=(const class wxULongLongWx &ll); +#endif + + // assignment operators from wxULongLongNative is ok + + // accessors + // get high part + wxUint32 GetHi() const + { return wx_truncate_cast(wxUint32, m_ll >> 32); } + // get low part + wxUint32 GetLo() const + { return wx_truncate_cast(wxUint32, m_ll); } + + // convert to native ulong long + wxULongLong_t GetValue() const { return m_ll; } + + // convert to ulong with range checking in debug mode (only!) + unsigned long ToULong() const + { + wxASSERT_MSG( m_ll <= LONG_MAX, + _T("wxULongLong to long conversion loss of precision") ); + + return wx_truncate_cast(unsigned long, m_ll); + } + + // convert to double +#ifdef _MSC_VER + double ToDouble() const { return wx_truncate_cast(double, (__int64) m_ll); } +#else + double ToDouble() const { return wx_truncate_cast(double, m_ll); } +#endif + + // operations + // addition + wxULongLongNative operator+(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll + ll.m_ll); } + wxULongLongNative& operator+=(const wxULongLongNative& ll) + { m_ll += ll.m_ll; return *this; } + + wxULongLongNative operator+(const wxULongLong_t ll) const + { return wxULongLongNative(m_ll + ll); } + wxULongLongNative& operator+=(const wxULongLong_t ll) + { m_ll += ll; return *this; } + + // pre increment + wxULongLongNative& operator++() + { m_ll++; return *this; } + + // post increment + wxULongLongNative operator++(int) + { wxULongLongNative value(*this); m_ll++; return value; } + + // subtraction + wxULongLongNative operator-(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll - ll.m_ll); } + wxULongLongNative& operator-=(const wxULongLongNative& ll) + { m_ll -= ll.m_ll; return *this; } + + wxULongLongNative operator-(const wxULongLong_t ll) const + { return wxULongLongNative(m_ll - ll); } + wxULongLongNative& operator-=(const wxULongLong_t ll) + { m_ll -= ll; return *this; } + + // pre decrement + wxULongLongNative& operator--() + { m_ll--; return *this; } + + // post decrement + wxULongLongNative operator--(int) + { wxULongLongNative value(*this); m_ll--; return value; } + + // shifts + // left shift + wxULongLongNative operator<<(int shift) const + { return wxULongLongNative(m_ll << shift); } + wxULongLongNative& operator<<=(int shift) + { m_ll <<= shift; return *this; } + + // right shift + wxULongLongNative operator>>(int shift) const + { return wxULongLongNative(m_ll >> shift); } + wxULongLongNative& operator>>=(int shift) + { m_ll >>= shift; return *this; } + + // bitwise operators + wxULongLongNative operator&(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll & ll.m_ll); } + wxULongLongNative& operator&=(const wxULongLongNative& ll) + { m_ll &= ll.m_ll; return *this; } + + wxULongLongNative operator|(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll | ll.m_ll); } + wxULongLongNative& operator|=(const wxULongLongNative& ll) + { m_ll |= ll.m_ll; return *this; } + + wxULongLongNative operator^(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll ^ ll.m_ll); } + wxULongLongNative& operator^=(const wxULongLongNative& ll) + { m_ll ^= ll.m_ll; return *this; } + + // multiplication/division + wxULongLongNative operator*(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll * ll.m_ll); } + wxULongLongNative operator*(unsigned long l) const + { return wxULongLongNative(m_ll * l); } + wxULongLongNative& operator*=(const wxULongLongNative& ll) + { m_ll *= ll.m_ll; return *this; } + wxULongLongNative& operator*=(unsigned long l) + { m_ll *= l; return *this; } + + wxULongLongNative operator/(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll / ll.m_ll); } + wxULongLongNative operator/(unsigned long l) const + { return wxULongLongNative(m_ll / l); } + wxULongLongNative& operator/=(const wxULongLongNative& ll) + { m_ll /= ll.m_ll; return *this; } + wxULongLongNative& operator/=(unsigned long l) + { m_ll /= l; return *this; } + + wxULongLongNative operator%(const wxULongLongNative& ll) const + { return wxULongLongNative(m_ll % ll.m_ll); } + wxULongLongNative operator%(unsigned long l) const + { return wxULongLongNative(m_ll % l); } + + // comparison + bool operator==(const wxULongLongNative& ll) const + { return m_ll == ll.m_ll; } + bool operator==(unsigned long l) const + { return m_ll == l; } + bool operator!=(const wxULongLongNative& ll) const + { return m_ll != ll.m_ll; } + bool operator!=(unsigned long l) const + { return m_ll != l; } + bool operator<(const wxULongLongNative& ll) const + { return m_ll < ll.m_ll; } + bool operator<(unsigned long l) const + { return m_ll < l; } + bool operator>(const wxULongLongNative& ll) const + { return m_ll > ll.m_ll; } + bool operator>(unsigned long l) const + { return m_ll > l; } + bool operator<=(const wxULongLongNative& ll) const + { return m_ll <= ll.m_ll; } + bool operator<=(unsigned long l) const + { return m_ll <= l; } + bool operator>=(const wxULongLongNative& ll) const + { return m_ll >= ll.m_ll; } + bool operator>=(unsigned long l) const + { return m_ll >= l; } + + // miscellaneous + + // return the string representation of this number + wxString ToString() const; + + // conversion to byte array: returns a pointer to static buffer! + void *asArray() const; + +#if wxUSE_STD_IOSTREAM + // input/output + friend WXDLLIMPEXP_BASE + wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&); +#endif + + friend WXDLLIMPEXP_BASE + wxString& operator<<(wxString&, const wxULongLongNative&); + +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongNative&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongNative&); +#endif + +private: + wxULongLong_t m_ll; +}; + +inline +wxLongLongNative& wxLongLongNative::operator=(const wxULongLongNative &ll) +{ + m_ll = ll.GetValue(); + return *this; +} + #endif // wxUSE_LONGLONG_NATIVE #if wxUSE_LONGLONG_WX -class WXDLLEXPORT wxLongLongWx +class WXDLLIMPEXP_BASE wxLongLongWx { public: // ctors @@ -367,7 +625,34 @@ public: return *this; } - // from double + // from int + wxLongLongWx& operator=(int l) + { + return operator=((long)l); + } + + wxLongLongWx& operator=(unsigned long l) + { + m_lo = l; + m_hi = 0; + +#ifdef wxLONGLONG_TEST_MODE + m_ll = l; + + Check(); +#endif // wxLONGLONG_TEST_MODE + + return *this; + } + + wxLongLongWx& operator=(unsigned int l) + { + return operator=((unsigned long)l); + } + + wxLongLongWx& operator=(const class wxULongLongWx &ll); + + // from double wxLongLongWx& Assign(double d); // can't have assignment operator from 2 longs @@ -394,7 +679,7 @@ public: return *this; } - // convert to long with range checking in the debug mode (only!) + // convert to long with range checking in debug mode (only!) long ToLong() const { wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l), @@ -403,6 +688,9 @@ public: return (long)m_lo; } + // convert to double + double ToDouble() const; + // operations // addition wxLongLongWx operator+(const wxLongLongWx& ll) const; @@ -451,6 +739,10 @@ public: // comparison bool operator==(const wxLongLongWx& ll) const { return m_lo == ll.m_lo && m_hi == ll.m_hi; } +#if wxUSE_LONGLONG_NATIVE + bool operator==(const wxLongLongNative& ll) const + { return m_lo == ll.GetLo() && m_hi == ll.GetHi(); } +#endif bool operator!=(const wxLongLongWx& ll) const { return !(*this == ll); } bool operator<(const wxLongLongWx& ll) const; @@ -460,6 +752,17 @@ public: bool operator>=(const wxLongLongWx& ll) const { return *this > ll || *this == ll; } + bool operator<(long l) const { return *this < wxLongLongWx(l); } + bool operator>(long l) const { return *this > wxLongLongWx(l); } + bool operator==(long l) const + { + return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l) + : (m_hi == -1 && m_lo == (unsigned long)l); + } + + bool operator<=(long l) const { return *this < l || *this == l; } + bool operator>=(long l) const { return *this > l || *this == l; } + // multiplication wxLongLongWx operator*(const wxLongLongWx& ll) const; wxLongLongWx& operator*=(const wxLongLongWx& ll); @@ -475,11 +778,26 @@ public: wxLongLongWx& remainder) const; // input/output + + // return the string representation of this number + wxString ToString() const; + + void *asArray() const; + #if wxUSE_STD_IOSTREAM - friend ostream& operator<<(ostream&, const wxLongLongWx&); + friend WXDLLIMPEXP_BASE + wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&); #endif // wxUSE_STD_IOSTREAM - void *asArray() const; + friend WXDLLIMPEXP_BASE + wxString& operator<<(wxString&, const wxLongLongWx&); + +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongWx&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongWx&); +#endif private: // long is at least 32 bits, so represent our 64bit number as 2 longs @@ -497,20 +815,266 @@ private: #endif // wxLONGLONG_TEST_MODE }; + +class WXDLLIMPEXP_BASE wxULongLongWx +{ +public: + // ctors + // default ctor initializes to 0 + wxULongLongWx() + { + m_lo = m_hi = 0; + +#ifdef wxLONGLONG_TEST_MODE + m_ll = 0; + + Check(); +#endif // wxLONGLONG_TEST_MODE + } + // from ulong + wxULongLongWx(unsigned long l) { *this = l; } + // from 2 ulongs + wxULongLongWx(unsigned long hi, unsigned long lo) + { + m_hi = hi; + m_lo = lo; + +#ifdef wxLONGLONG_TEST_MODE + m_ll = hi; + m_ll <<= 32; + m_ll |= lo; + + Check(); +#endif // wxLONGLONG_TEST_MODE + } + + // from signed to unsigned + wxULongLongWx(wxLongLongWx ll) + { + wxASSERT(ll.GetHi() >= 0); + m_hi = (unsigned long)ll.GetHi(); + m_lo = ll.GetLo(); + } + + // default copy ctor is ok in both cases + + // no dtor + + // assignment operators + // from long + wxULongLongWx& operator=(unsigned long l) + { + m_lo = l; + m_hi = 0; + +#ifdef wxLONGLONG_TEST_MODE + m_ll = l; + + Check(); +#endif // wxLONGLONG_TEST_MODE + + return *this; + } + wxULongLongWx& operator=(long l) + { + m_lo = l; + m_hi = (unsigned long) ((l<0) ? -1l : 0); + +#ifdef wxLONGLONG_TEST_MODE + m_ll = (wxULongLong_t) (wxLongLong_t) l; + + Check(); +#endif // wxLONGLONG_TEST_MODE + + return *this; + } + wxULongLongWx& operator=(const class wxLongLongWx &ll) { + // Should we use an assert like it was before in the constructor? + // wxASSERT(ll.GetHi() >= 0); + m_hi = (unsigned long)ll.GetHi(); + m_lo = ll.GetLo(); + return *this; + } + + // can't have assignment operator from 2 longs + + // accessors + // get high part + unsigned long GetHi() const { return m_hi; } + // get low part + unsigned long GetLo() const { return m_lo; } + + // convert to long with range checking in debug mode (only!) + unsigned long ToULong() const + { + wxASSERT_MSG( m_hi == 0ul, + _T("wxULongLong to long conversion loss of precision") ); + + return (unsigned long)m_lo; + } + + // convert to double + double ToDouble() const; + + // operations + // addition + wxULongLongWx operator+(const wxULongLongWx& ll) const; + wxULongLongWx& operator+=(const wxULongLongWx& ll); + wxULongLongWx operator+(unsigned long l) const; + wxULongLongWx& operator+=(unsigned long l); + + // pre increment operator + wxULongLongWx& operator++(); + + // post increment operator + wxULongLongWx& operator++(int) { return ++(*this); } + + // subtraction + wxLongLongWx operator-(const wxULongLongWx& ll) const; + wxULongLongWx& operator-=(const wxULongLongWx& ll); + + // pre decrement operator + wxULongLongWx& operator--(); + + // post decrement operator + wxULongLongWx& operator--(int) { return --(*this); } + + // shifts + // left shift + wxULongLongWx operator<<(int shift) const; + wxULongLongWx& operator<<=(int shift); + + // right shift + wxULongLongWx operator>>(int shift) const; + wxULongLongWx& operator>>=(int shift); + + // bitwise operators + wxULongLongWx operator&(const wxULongLongWx& ll) const; + wxULongLongWx& operator&=(const wxULongLongWx& ll); + wxULongLongWx operator|(const wxULongLongWx& ll) const; + wxULongLongWx& operator|=(const wxULongLongWx& ll); + wxULongLongWx operator^(const wxULongLongWx& ll) const; + wxULongLongWx& operator^=(const wxULongLongWx& ll); + wxULongLongWx operator~() const; + + // comparison + bool operator==(const wxULongLongWx& ll) const + { return m_lo == ll.m_lo && m_hi == ll.m_hi; } + bool operator!=(const wxULongLongWx& ll) const + { return !(*this == ll); } + bool operator<(const wxULongLongWx& ll) const; + bool operator>(const wxULongLongWx& ll) const; + bool operator<=(const wxULongLongWx& ll) const + { return *this < ll || *this == ll; } + bool operator>=(const wxULongLongWx& ll) const + { return *this > ll || *this == ll; } + + bool operator<(unsigned long l) const { return *this < wxULongLongWx(l); } + bool operator>(unsigned long l) const { return *this > wxULongLongWx(l); } + bool operator==(unsigned long l) const + { + return (m_hi == 0 && m_lo == (unsigned long)l); + } + + bool operator<=(unsigned long l) const { return *this < l || *this == l; } + bool operator>=(unsigned long l) const { return *this > l || *this == l; } + + // multiplication + wxULongLongWx operator*(const wxULongLongWx& ll) const; + wxULongLongWx& operator*=(const wxULongLongWx& ll); + + // division + wxULongLongWx operator/(const wxULongLongWx& ll) const; + wxULongLongWx& operator/=(const wxULongLongWx& ll); + + wxULongLongWx operator%(const wxULongLongWx& ll) const; + + void Divide(const wxULongLongWx& divisor, + wxULongLongWx& quotient, + wxULongLongWx& remainder) const; + + // input/output + + // return the string representation of this number + wxString ToString() const; + + void *asArray() const; + +#if wxUSE_STD_IOSTREAM + friend WXDLLIMPEXP_BASE + wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&); +#endif // wxUSE_STD_IOSTREAM + + friend WXDLLIMPEXP_BASE + wxString& operator<<(wxString&, const wxULongLongWx&); + +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongWx&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongWx&); +#endif + +private: + // long is at least 32 bits, so represent our 64bit number as 2 longs + + unsigned long m_hi; + unsigned long m_lo; + +#ifdef wxLONGLONG_TEST_MODE + void Check() + { + wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo ); + } + + wxULongLong_t m_ll; +#endif // wxLONGLONG_TEST_MODE +}; + #endif // wxUSE_LONGLONG_WX // ---------------------------------------------------------------------------- // binary operators // ---------------------------------------------------------------------------- -inline bool WXDLLEXPORT operator<(long l, const wxLongLong& ll) { return ll > l; } -inline bool WXDLLEXPORT operator>(long l, const wxLongLong& ll) { return ll > l; } -inline bool WXDLLEXPORT operator<=(long l, const wxLongLong& ll) { return ll > l; } -inline bool WXDLLEXPORT operator>=(long l, const wxLongLong& ll) { return ll > l; } -inline bool WXDLLEXPORT operator==(long l, const wxLongLong& ll) { return ll > l; } -inline bool WXDLLEXPORT operator!=(long l, const wxLongLong& ll) { return ll > l; } +inline bool operator<(long l, const wxLongLong& ll) { return ll > l; } +inline bool operator>(long l, const wxLongLong& ll) { return ll < l; } +inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; } +inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; } +inline bool operator==(long l, const wxLongLong& ll) { return ll == l; } +inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; } + +inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; } +inline wxLongLong operator-(long l, const wxLongLong& ll) +{ + return wxLongLong(l) - ll; +} + +inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; } +inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; } +inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; } +inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; } +inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; } +inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; } + +inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; } + +inline wxLongLong operator-(unsigned long l, const wxULongLong& ull) +{ + wxULongLong ret = wxULongLong(l) - ull; + return wxLongLong((long)ret.GetHi(),ret.GetLo()); +} + +#if wxUSE_LONGLONG_NATIVE && wxUSE_STREAMS + +WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxULongLong_t value); +WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxLongLong_t value); + +WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxULongLong_t &value); +WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxLongLong_t &value); + +#endif -inline wxLongLong WXDLLEXPORT operator+(long l, const wxLongLong& ll) { return ll + l; } -inline wxLongLong WXDLLEXPORT operator-(long l, const wxLongLong& ll) { return ll - l; } +#endif // wxUSE_LONGLONG #endif // _WX_LONGLONG_H