#pragma interface "longlong.h"
#endif
+#include "wx/defs.h"
+#include "wx/wxchar.h"
+#include "wx/debug.h"
+
+#include <limits.h> // for LONG_MAX
+
+#define wxUSE_LONGLONG_WX 1
+
// ----------------------------------------------------------------------------
// decide upon which class we will use
// ----------------------------------------------------------------------------
#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
#define wxLongLong_t long
#define wxLongLongIsLong
-#elif defined(__VISUALC__)
+#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
#error "The 64 bit integer support in CodeWarrior has been disabled."
#error "See the documentation on the 'longlong' pragma."
#endif
-#else
- #warning "Your compiler does not appear to support 64 bit integers, "\
- "using emulation class instead."
+#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__) && \
+ !defined(__BORLANDC__
+ #warning "Your compiler does not appear to support 64 bit integers, "\
+ "using emulation class instead."
+ #endif // known compilers without long long
+
#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
+#if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
#undef wxUSE_LONGLONG_NATIVE
#define wxUSE_LONGLONG_NATIVE 0
class WXDLLEXPORT wxLongLongWx;
wxLongLongNative& operator=(wxLongLong_t ll)
{ m_ll = ll; return *this; }
+ // from double: this one has an explicit name because otherwise we
+ // would have ambiguity with "ll = int" and also because we don't want
+ // to have implicit conversions between doubles and wxLongLongs
+ wxLongLongNative& Assign(double d)
+ { m_ll = (wxLongLong_t)d; return *this; }
+
// assignment operators from wxLongLongNative is ok
// accessors
{ 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
wxLongLong_t GetValue() const { return m_ll; }
+ // convert to long with range checking in the 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;
+ }
+
// 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; }
// from long
wxLongLongWx& operator=(long l)
{ m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
+ // from double
+ wxLongLongWx& Assign(double d);
// can't have assignment operator from 2 longs
// accessors
// get low part
unsigned long GetLo() const { return m_lo; }
+ // get absolute value
+ wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
+ wxLongLongWx& Abs() { if ( m_hi < 0 ) m_hi = -m_hi; return *this; }
+
+ // convert to long with range checking in the debug mode (only!)
+ long ToLong() const
+ {
+ wxASSERT_MSG( m_hi == 0l,
+ _T("wxLongLong to long conversion loss of precision") );
+
+ return (long)m_lo;
+ }
+
// operations
// addition
wxLongLongWx operator+(const wxLongLongWx& ll) const;
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
+ { return *this < ll || *this == ll; }
+ bool operator>=(const wxLongLongWx& ll) const
+ { return *this > ll || *this == ll; }
// multiplication
wxLongLongWx operator*(const wxLongLongWx& ll) const;
wxLongLongWx& operator*=(const wxLongLongWx& ll);
- void *asArray(void) const;
// division
+ wxLongLongWx operator/(const wxLongLongWx& ll) const;
+ wxLongLongWx& operator/=(const wxLongLongWx& ll);
+
+ wxLongLongWx operator%(const wxLongLongWx& ll) const;
+
void Divide(const wxLongLongWx& divisor,
wxLongLongWx& quotient,
wxLongLongWx& remainder) const;
-#if wxUSE_STD_IOSTREAM
// input/output
+#if wxUSE_STD_IOSTREAM
friend ostream& operator<<(ostream&, const wxLongLongWx&);
#endif // wxUSE_STD_IOSTREAM
+ void *asArray(void) const;
+
private:
// long is at least 32 bits, so represent our 64bit number as 2 longs
#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
projects / wxWidgets.git / blobdiff