applied patch 103575 (more efficient wxString comparison)

[wxWidgets.git] / include / wx / longlong.h

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index 3a502e70d79db0dabdba831ae8383d9122fcb698..31baf4810e7512a3db290f0c79b121f0487385ac 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -3,8 +3,6 @@
 // Purpose:     declaration of wxLongLong class - best implementation of a 64
 //              bit integer for the current platform.
 // Author:      Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
 // Purpose:     declaration of wxLongLong class - best implementation of a 64
 //              bit integer for the current platform.
 // Author:      Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, 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$
 // Modified by:
 // Created:     10.02.99
 // RCS-ID:      $Id$


@@ -21,10 +19,21 @@
 
 #include "wx/defs.h"
 #include "wx/wxchar.h"
 
 #include "wx/defs.h"
 #include "wx/wxchar.h"

-#include "wx/debug.h"

 
 #include <limits.h>     // for LONG_MAX
 
 
 #include <limits.h>     // for LONG_MAX
 

+// define this to compile wxLongLongWx in "test" mode: the results of all
+// calculations will be compared with the real results taken from
+// wxLongLongNative -- this is extremely useful to find the bugs in
+// wxLongLongWx class!
+
+// #define wxLONGLONG_TEST_MODE
+
+#ifdef wxLONGLONG_TEST_MODE
+    #define wxUSE_LONGLONG_WX 1
+    #define wxUSE_LONGLONG_NATIVE 1
+#endif // wxLONGLONG_TEST_MODE
+

 // ----------------------------------------------------------------------------
 // decide upon which class we will use
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // decide upon which class we will use
 // ----------------------------------------------------------------------------


@@ -41,6 +50,8 @@
     #define wxLongLongIsLong
 #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
     #define wxLongLong_t __int64
     #define wxLongLongIsLong
 #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
     #define wxLongLong_t __int64

+#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
+    #define wxLongLong_t __int64

 #elif defined(__GNUG__)
     #define wxLongLong_t long long
 #elif defined(__MWERKS__)
 #elif defined(__GNUG__)
     #define wxLongLong_t long long
 #elif defined(__MWERKS__)


@@ -50,23 +61,29 @@
         #error "The 64 bit integer support in CodeWarrior has been disabled."
         #error "See the documentation on the 'longlong' pragma."
     #endif
         #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
 #else // no native long long type

-    // we don't give warnings for the compilers we know about that they don't
-    // have any 64 bit integer type
-    #if !defined(__VISAGECPP__) && !defined(__VISUALC__)
-        #warning "Your compiler does not appear to support 64 bit integers, "\
-                 "using emulation class instead."
-    #endif // known compilers without long long
-
+    // both warning and pragma warning are not portable, but at least an
+    // unknown pragma should never be an error - unless the compiler is
+    // seriously broken as Watcom C++ seems to be...
+#if (!(defined(__WATCOMC__) || defined(__VISAGECPP__)))
+    #pragma warning "Your compiler does not appear to support 64 bit "\
+                    "integers, using emulation class instead."
+#endif

     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
 // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
 // to disable automatic testing (useful for the test program which defines
 // both classes) but by default we only use one class
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
 // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
 // to disable automatic testing (useful for the test program which defines
 // both classes) but by default we only use one class

-#ifndef wxLongLong_t
-    #undef wxUSE_LONGLONG_NATIVE
-    #define wxUSE_LONGLONG_NATIVE 0
+#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 and only there
+    #ifndef wxUSE_LONGLONG_NATIVE
+        #define wxUSE_LONGLONG_NATIVE 0
+    #endif
+

     class WXDLLEXPORT wxLongLongWx;
     typedef wxLongLongWx wxLongLong;
 #else
     class WXDLLEXPORT wxLongLongWx;
     typedef wxLongLongWx wxLongLong;
 #else


@@ -136,6 +153,7 @@ public:
         { return (unsigned long)m_ll; }
 
         // get absolute value
         { return (unsigned long)m_ll; }
 
         // get absolute value

+    wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }

     wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
 
         // convert to native long long
     wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
 
         // convert to native long long


@@ -298,13 +316,32 @@ class WXDLLEXPORT wxLongLongWx
 public:
     // ctors
         // default ctor initializes to 0
 public:
     // ctors
         // default ctor initializes to 0

-    wxLongLongWx() { m_lo = m_hi = 0; }
+    wxLongLongWx()
+    {
+        m_lo = m_hi = 0;
+
+#ifdef wxLONGLONG_TEST_MODE
+        m_ll = 0;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+    }

         // from long
         // from long

-    wxLongLongWx(long l)
-        { m_lo = l; m_hi = (l < 0 ? -1l : 0l); }
+    wxLongLongWx(long l) { *this = l; }

         // from 2 longs
     wxLongLongWx(long hi, unsigned long lo)
         // from 2 longs
     wxLongLongWx(long hi, unsigned long lo)

-        { m_hi = hi; m_lo = 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
+    }

 
     // default copy ctor is ok in both cases
 
 
     // default copy ctor is ok in both cases
 


@@ -313,7 +350,18 @@ public:
     // assignment operators
         // from long
     wxLongLongWx& operator=(long l)
     // assignment operators
         // from long
     wxLongLongWx& operator=(long l)

-        { m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
+    {
+        m_lo = l;
+        m_hi = (l < 0 ? -1l : 0l);
+
+#ifdef wxLONGLONG_TEST_MODE
+        m_ll = l;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+
+        return *this;
+    }

         // from double
     wxLongLongWx& Assign(double d);
         // can't have assignment operator from 2 longs
         // from double
     wxLongLongWx& Assign(double d);
         // can't have assignment operator from 2 longs


@@ -325,12 +373,26 @@ public:
     unsigned long GetLo() const { return m_lo; }
 
         // get absolute value
     unsigned long GetLo() const { return m_lo; }
 
         // get absolute value

-    wxLongLongWx& Abs() { if ( m_hi < 0 ) m_hi = -m_hi; return *this; }
+    wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
+    wxLongLongWx& Abs()
+    {
+        if ( m_hi < 0 )
+            m_hi = -m_hi;
+
+#ifdef wxLONGLONG_TEST_MODE
+        if ( m_ll < 0 )
+            m_ll = -m_ll;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+
+        return *this;
+    }

 
         // convert to long with range checking in the debug mode (only!)
     long ToLong() const
     {
 
         // convert to long with range checking in the debug mode (only!)
     long ToLong() const
     {

-        wxASSERT_MSG( m_hi == 0l,
+        wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l),

                       _T("wxLongLong to long conversion loss of precision") );
 
         return (long)m_lo;
                       _T("wxLongLong to long conversion loss of precision") );
 
         return (long)m_lo;


@@ -347,10 +409,11 @@ public:
     wxLongLongWx& operator++();
 
         // post increment operator
     wxLongLongWx& operator++();
 
         // post increment operator

-    wxLongLongWx& operator++(int);
+    wxLongLongWx& operator++(int) { return ++(*this); }

 
         // negation operator
     wxLongLongWx operator-() const;
 
         // negation operator
     wxLongLongWx operator-() const;

+    wxLongLongWx& Negate();

 
         // subraction
     wxLongLongWx operator-(const wxLongLongWx& ll) const;
 
         // subraction
     wxLongLongWx operator-(const wxLongLongWx& ll) const;


@@ -360,7 +423,7 @@ public:
     wxLongLongWx& operator--();
 
         // post decrement operator
     wxLongLongWx& operator--();
 
         // post decrement operator

-    wxLongLongWx& operator--(int);
+    wxLongLongWx& operator--(int) { return --(*this); }

 
     // shifts
         // left shift
 
     // shifts
         // left shift


@@ -381,12 +444,27 @@ public:
     wxLongLongWx operator~() const;
 
     // comparison
     wxLongLongWx operator~() const;
 
     // comparison

-    bool operator==(const wxLongLongWx& ll) const;
-    bool operator!=(const wxLongLongWx& ll) const;
+    bool operator==(const wxLongLongWx& ll) const
+        { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
+    bool operator!=(const wxLongLongWx& ll) const
+        { return !(*this == ll); }

     bool operator<(const wxLongLongWx& ll) const;
     bool operator>(const wxLongLongWx& ll) const;
     bool operator<(const wxLongLongWx& ll) const;
     bool operator>(const wxLongLongWx& ll) const;

-    bool operator<=(const wxLongLongWx& ll) const;
-    bool operator>=(const wxLongLongWx& ll) const;
+    bool operator<=(const wxLongLongWx& ll) const
+        { return *this < ll || *this == ll; }
+    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;
 
     // multiplication
     wxLongLongWx operator*(const wxLongLongWx& ll) const;


@@ -407,15 +485,38 @@ public:
     friend ostream& operator<<(ostream&, const wxLongLongWx&);
 #endif // wxUSE_STD_IOSTREAM
 
     friend ostream& operator<<(ostream&, const wxLongLongWx&);
 #endif // wxUSE_STD_IOSTREAM
 

-    void *asArray(void) const;
+    void *asArray() const;

 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
     long m_hi;                // signed bit is in the high part
     unsigned long m_lo;
 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
     long m_hi;                // signed bit is in the high part
     unsigned long m_lo;

+
+#ifdef wxLONGLONG_TEST_MODE
+    void Check()
+    {
+        wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
+    }
+
+    wxLongLong_t m_ll;
+#endif // wxLONGLONG_TEST_MODE

 };
 
 #endif // wxUSE_LONGLONG_WX
 
 };
 
 #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 wxLongLong WXDLLEXPORT operator+(long l, const wxLongLong& ll) { return ll + l; }
+inline wxLongLong WXDLLEXPORT operator-(long l, const wxLongLong& ll) { return ll - l; }
+

 #endif // _WX_LONGLONG_H
 #endif // _WX_LONGLONG_H