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

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/longlong.h
// 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$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

#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"

#include <limits.h>     // for LONG_MAX

// ----------------------------------------------------------------------------
// 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__)
    #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
#else
    #warning "Your compiler does not appear to support 64 bit integers, "\
             "using emulation class instead."
    #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
    class WXDLLEXPORT wxLongLongWx;
    typedef wxLongLongWx wxLongLong;
#else
    // if nothing is defined, use native implementation by default, of course
    #ifndef wxUSE_LONGLONG_NATIVE
        #define wxUSE_LONGLONG_NATIVE 1
    #endif
#endif

#ifndef wxUSE_LONGLONG_WX
    #define wxUSE_LONGLONG_WX 0
    class WXDLLEXPORT wxLongLongNative;
    typedef wxLongLongNative wxLongLong;
#endif

// NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should
//     typedef wxLongLong as it wants, we don't do it

// ----------------------------------------------------------------------------
// choose the appropriate class
// ----------------------------------------------------------------------------

// we use iostream for wxLongLong output
#include "wx/ioswrap.h"

#if wxUSE_LONGLONG_NATIVE

class WXDLLEXPORT wxLongLongNative
{
public:
    // ctors
        // default ctor initializes to 0
    wxLongLongNative() { m_ll = 0; }
        // from long long
    wxLongLongNative(wxLongLong_t ll) { m_ll = ll; }
        // from 2 longs
    wxLongLongNative(long hi, unsigned long lo)
    {
        // assign first to avoid precision loss!
        m_ll = ((wxLongLong_t) hi) << 32;
        m_ll |= (wxLongLong_t) lo;
    }

    // default copy ctor is ok

    // no dtor

    // assignment operators
        // from native 64 bit integer
    wxLongLongNative& operator=(wxLongLong_t ll)
        { m_ll = ll; return *this; }

    // assignment operators from wxLongLongNative is ok

    // accessors
        // get high part
    long GetHi() const
        { return (long)(m_ll >> 32); }
        // get low part
    unsigned long GetLo() const
        { return (unsigned long)m_ll; }

        // get absolute value
    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; }

    // operations
        // addition
    wxLongLongNative operator+(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll + ll.m_ll); }
    wxLongLongNative& operator+=(const wxLongLongNative& ll)
        { m_ll += ll.m_ll; return *this; }

    wxLongLongNative operator+(const wxLongLong_t ll) const
        { return wxLongLongNative(m_ll + ll); }
    wxLongLongNative& operator+=(const wxLongLong_t ll)
        { m_ll += ll; return *this; }

        // pre increment
    wxLongLongNative& operator++()
        { m_ll++; return *this; }

        // post increment
    wxLongLongNative& operator++(int)
        { m_ll++; return *this; }

        // negation operator
    wxLongLongNative operator-() const
        { return wxLongLongNative(-m_ll); }

        // subtraction
    wxLongLongNative operator-(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll - ll.m_ll); }
    wxLongLongNative& operator-=(const wxLongLongNative& ll)
        { m_ll -= ll.m_ll; return *this; }

    wxLongLongNative operator-(const wxLongLong_t ll) const
        { return wxLongLongNative(m_ll - ll); }
    wxLongLongNative& operator-=(const wxLongLong_t ll)
        { m_ll -= ll; return *this; }

        // pre decrement
    wxLongLongNative& operator--()
        { m_ll--; return *this; }

        // post decrement
    wxLongLongNative& operator--(int)
        { m_ll--; return *this; }

    // shifts
        // left shift
    wxLongLongNative operator<<(int shift) const
        { 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);; }
    wxLongLongNative& operator>>=(int shift)
        { m_ll >>= shift; return *this; }

    // bitwise operators
    wxLongLongNative operator&(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll & ll.m_ll); }
    wxLongLongNative& operator&=(const wxLongLongNative& ll)
        { m_ll &= ll.m_ll; return *this; }

    wxLongLongNative operator|(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll | ll.m_ll); }
    wxLongLongNative& operator|=(const wxLongLongNative& ll)
        { m_ll |= ll.m_ll; return *this; }

    wxLongLongNative operator^(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll ^ ll.m_ll); }
    wxLongLongNative& operator^=(const wxLongLongNative& ll)
        { m_ll ^= ll.m_ll; return *this; }

    // multiplication/division
    wxLongLongNative operator*(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll * ll.m_ll); }
    wxLongLongNative operator*(long l) const
        { return wxLongLongNative(m_ll * l); }
    wxLongLongNative& operator*=(const wxLongLongNative& ll)
        { m_ll *= ll.m_ll; return *this; }
    wxLongLongNative& operator*=(long l)
        { m_ll *= l; return *this; }

    wxLongLongNative operator/(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll / ll.m_ll); }
    wxLongLongNative operator/(long l) const
        { return wxLongLongNative(m_ll / l); }
    wxLongLongNative& operator/=(const wxLongLongNative& ll)
        { m_ll /= ll.m_ll; return *this; }
    wxLongLongNative& operator/=(long l)
        { m_ll /= l; return *this; }

    wxLongLongNative operator%(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll % ll.m_ll); }
    wxLongLongNative operator%(long l) const
        { return wxLongLongNative(m_ll % l); }

    // comparison
    bool operator==(const wxLongLongNative& ll) const
        { return m_ll == ll.m_ll; }
    bool operator==(long l) const
        { return m_ll == l; }
    bool operator!=(const wxLongLongNative& ll) const
        { return m_ll != ll.m_ll; }
    bool operator!=(long l) const
        { return m_ll != l; }
    bool operator<(const wxLongLongNative& ll) const
        { return m_ll < ll.m_ll; }
    bool operator<(long l) const
        { return m_ll < l; }
    bool operator>(const wxLongLongNative& ll) const
        { return m_ll > ll.m_ll; }
    bool operator>(long l) const
        { return m_ll > l; }
    bool operator<=(const wxLongLongNative& ll) const
        { return m_ll <= ll.m_ll; }
    bool operator<=(long l) const
        { return m_ll <= l; }
    bool operator>=(const wxLongLongNative& ll) const
        { return m_ll >= ll.m_ll; }
    bool operator>=(long l) const
        { return m_ll >= l; }

    // miscellaneous
        // 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&);
#endif

private:
    wxLongLong_t  m_ll;
};

#endif // wxUSE_LONGLONG_NATIVE

#if wxUSE_LONGLONG_WX

class WXDLLEXPORT wxLongLongWx
{
public:
    // ctors
        // default ctor initializes to 0
    wxLongLongWx() { m_lo = m_hi = 0; }
        // from long
    wxLongLongWx(long l)
        { m_lo = l; m_hi = (l < 0 ? -1l : 0l); }
        // from 2 longs
    wxLongLongWx(long hi, unsigned long lo)
        { m_hi = hi; m_lo = lo; }

    // default copy ctor is ok in both cases

    // no dtor

    // assignment operators
        // from long
    wxLongLongWx& operator=(long l)
        { m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
        // can't have assignment operator from 2 longs

    // accessors
        // get high part
    long GetHi() const { return m_hi; }
        // get low part
    unsigned long GetLo() const { return m_lo; }

    // operations
        // addition
    wxLongLongWx operator+(const wxLongLongWx& ll) const;
    wxLongLongWx& operator+=(const wxLongLongWx& ll);
    wxLongLongWx operator+(long l) const;
    wxLongLongWx& operator+=(long l);

        // pre increment operator
    wxLongLongWx& operator++();

        // post increment operator
    wxLongLongWx& operator++(int);

        // negation operator
    wxLongLongWx operator-() const;

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

        // pre decrement operator
    wxLongLongWx& operator--();

        // post decrement operator
    wxLongLongWx& operator--(int);

    // shifts
        // left shift
    wxLongLongWx operator<<(int shift) const;
    wxLongLongWx& operator<<=(int shift);

        // right shift
    wxLongLongWx operator>>(int shift) const;
    wxLongLongWx& operator>>=(int shift);

    // bitwise operators
    wxLongLongWx operator&(const wxLongLongWx& ll) const;
    wxLongLongWx& operator&=(const wxLongLongWx& ll);
    wxLongLongWx operator|(const wxLongLongWx& ll) const;
    wxLongLongWx& operator|=(const wxLongLongWx& ll);
    wxLongLongWx operator^(const wxLongLongWx& ll) const;
    wxLongLongWx& operator^=(const wxLongLongWx& ll);
    wxLongLongWx operator~() const;

    // comparison
    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;

    // multiplication
    wxLongLongWx operator*(const wxLongLongWx& ll) const;
    wxLongLongWx& operator*=(const wxLongLongWx& ll);
    void *asArray(void) const;

    // division
    void Divide(const wxLongLongWx& divisor,
                wxLongLongWx& quotient,
                wxLongLongWx& remainder) const;

#if wxUSE_STD_IOSTREAM
    // input/output
    friend ostream& operator<<(ostream&, const wxLongLongWx&);
#endif // wxUSE_STD_IOSTREAM

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;
};

#endif // wxUSE_LONGLONG_WX

#endif // _WX_LONGLONG_H
Commit	Line	Data
8b81872f VZ	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	// Remarks: this class is not public in wxWindows 2.0! It is intentionally
	7	// not documented and is for private use only.
	8	// Modified by:
	9	// Created: 10.02.99
	10	// RCS-ID: $Id$
	11	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	12	// Licence: wxWindows license
	13	/////////////////////////////////////////////////////////////////////////////
	14
	15	#ifndef _WX_LONGLONG_H
	16	#define _WX_LONGLONG_H
	17
	18	#ifdef __GNUG__
	19	#pragma interface "longlong.h"
	20	#endif
	21
1ef54dcf VZ	22	#include "wx/defs.h"
	23	#include "wx/wxchar.h"
	24	#include "wx/debug.h"
	25
	26	#include <limits.h> // for LONG_MAX
	27
8b81872f VZ	28	// ----------------------------------------------------------------------------
	29	// decide upon which class we will use
	30	// ----------------------------------------------------------------------------
	31
	32	// to avoid compilation problems on 64bit machines with ambiguous method calls
2f02cb89	33	// we will need to define this
8b81872f VZ	34	#undef wxLongLongIsLong
	35
	36	// NB: we #define and not typedef wxLongLong_t because we want to be able to
2f02cb89 VZ	37	// use 'unsigned wxLongLong_t' as well and because we use "#ifdef
2f02cb89 VZ	38	// wxLongLong_t" below
8b81872f VZ	39	#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
	40	#define wxLongLong_t long
	41	#define wxLongLongIsLong
	42	#elif defined(__VISUALC__)
	43	#define wxLongLong_t __int64
	44	#elif defined(__GNUG__)
	45	#define wxLongLong_t long long
	46	#elif defined(__MWERKS__)
	47	#if __option(longlong)
	48	#define wxLongLong_t long long
	49	#else
	50	#error "The 64 bit integer support in CodeWarrior has been disabled."
	51	#error "See the documentation on the 'longlong' pragma."
	52	#endif
	53	#else
	54	#warning "Your compiler does not appear to support 64 bit integers, "\
	55	"using emulation class instead."
	56	#define wxUSE_LONGLONG_WX 1
	57	#endif // compiler
	58
	59	// the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
	60	// to disable automatic testing (useful for the test program which defines
	61	// both classes) but by default we only use one class
	62	#ifndef wxLongLong_t
	63	#undef wxUSE_LONGLONG_NATIVE
	64	#define wxUSE_LONGLONG_NATIVE 0
	65	class WXDLLEXPORT wxLongLongWx;
	66	typedef wxLongLongWx wxLongLong;
b76b015e VZ	67	#else
	68	// if nothing is defined, use native implementation by default, of course
	69	#ifndef wxUSE_LONGLONG_NATIVE
	70	#define wxUSE_LONGLONG_NATIVE 1
	71	#endif
8b81872f VZ	72	#endif
	73
	74	#ifndef wxUSE_LONGLONG_WX
	75	#define wxUSE_LONGLONG_WX 0
	76	class WXDLLEXPORT wxLongLongNative;
	77	typedef wxLongLongNative wxLongLong;
	78	#endif
	79
	80	// NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should
	81	// typedef wxLongLong as it wants, we don't do it
	82
	83	// ----------------------------------------------------------------------------
	84	// choose the appropriate class
	85	// ----------------------------------------------------------------------------
	86
	87	// we use iostream for wxLongLong output
	88	#include "wx/ioswrap.h"
	89
	90	#if wxUSE_LONGLONG_NATIVE
	91
	92	class WXDLLEXPORT wxLongLongNative
	93	{
	94	public:
	95	// ctors
	96	// default ctor initializes to 0
	97	wxLongLongNative() { m_ll = 0; }
	98	// from long long
	99	wxLongLongNative(wxLongLong_t ll) { m_ll = ll; }
	100	// from 2 longs
	101	wxLongLongNative(long hi, unsigned long lo)
	102	{
	103	// assign first to avoid precision loss!
	104	m_ll = ((wxLongLong_t) hi) << 32;
	105	m_ll \|= (wxLongLong_t) lo;
	106	}
	107
2f02cb89	108	// default copy ctor is ok
8b81872f VZ	109
	110	// no dtor
	111
	112	// assignment operators
	113	// from native 64 bit integer
	114	wxLongLongNative& operator=(wxLongLong_t ll)
	115	{ m_ll = ll; return *this; }
	116
	117	// assignment operators from wxLongLongNative is ok
	118
	119	// accessors
	120	// get high part
	121	long GetHi() const
2f02cb89	122	{ return (long)(m_ll >> 32); }
8b81872f VZ	123	// get low part
8b81872f VZ	124	unsigned long GetLo() const
2f02cb89	125	{ return (unsigned long)m_ll; }
8b81872f	126
b76b015e VZ	127	// get absolute value
	128	wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
	129
8b81872f VZ	130	// convert to native long long
	131	wxLongLong_t GetValue() const { return m_ll; }
	132
1ef54dcf VZ	133	// convert to long with range checking in the debug mode (only!)
	134	long ToLong() const
	135	{
	136	wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
	137	_T("wxLongLong to long conversion loss of precision") );
	138
	139	return (long)m_ll;
	140	}
	141
2f02cb89 VZ	142	// don't provide implicit conversion to wxLongLong_t or we will have an
2f02cb89 VZ	143	// ambiguity for all arithmetic operations
b76b015e	144	//operator wxLongLong_t() const { return m_ll; }
8b81872f VZ	145
	146	// operations
	147	// addition
	148	wxLongLongNative operator+(const wxLongLongNative& ll) const
	149	{ return wxLongLongNative(m_ll + ll.m_ll); }
	150	wxLongLongNative& operator+=(const wxLongLongNative& ll)
	151	{ m_ll += ll.m_ll; return *this; }
	152
	153	wxLongLongNative operator+(const wxLongLong_t ll) const
	154	{ return wxLongLongNative(m_ll + ll); }
	155	wxLongLongNative& operator+=(const wxLongLong_t ll)
	156	{ m_ll += ll; return *this; }
	157
	158	// pre increment
	159	wxLongLongNative& operator++()
	160	{ m_ll++; return *this; }
	161
	162	// post increment
	163	wxLongLongNative& operator++(int)
	164	{ m_ll++; return *this; }
	165
	166	// negation operator
	167	wxLongLongNative operator-() const
	168	{ return wxLongLongNative(-m_ll); }
	169
	170	// subtraction
	171	wxLongLongNative operator-(const wxLongLongNative& ll) const
	172	{ return wxLongLongNative(m_ll - ll.m_ll); }
	173	wxLongLongNative& operator-=(const wxLongLongNative& ll)
	174	{ m_ll -= ll.m_ll; return *this; }
	175
	176	wxLongLongNative operator-(const wxLongLong_t ll) const
	177	{ return wxLongLongNative(m_ll - ll); }
	178	wxLongLongNative& operator-=(const wxLongLong_t ll)
	179	{ m_ll -= ll; return *this; }
	180
	181	// pre decrement
	182	wxLongLongNative& operator--()
	183	{ m_ll--; return *this; }
	184
	185	// post decrement
	186	wxLongLongNative& operator--(int)
	187	{ m_ll--; return *this; }
	188
	189	// shifts
	190	// left shift
	191	wxLongLongNative operator<<(int shift) const
	192	{ return wxLongLongNative(m_ll << shift);; }
	193	wxLongLongNative& operator<<=(int shift)
	194	{ m_ll <<= shift; return *this; }
	195
	196	// right shift
	197	wxLongLongNative operator>>(int shift) const
	198	{ return wxLongLongNative(m_ll >> shift);; }
	199	wxLongLongNative& operator>>=(int shift)
	200	{ m_ll >>= shift; return *this; }
	201
	202	// bitwise operators
	203	wxLongLongNative operator&(const wxLongLongNative& ll) const
	204	{ return wxLongLongNative(m_ll & ll.m_ll); }
	205	wxLongLongNative& operator&=(const wxLongLongNative& ll)
	206	{ m_ll &= ll.m_ll; return *this; }
	207
	208	wxLongLongNative operator\|(const wxLongLongNative& ll) const
209	{ return wxLongLongNative(m_ll \| ll.m_ll); }
210	wxLongLongNative& operator\|=(const wxLongLongNative& ll)
211	{ m_ll \|= ll.m_ll; return *this; }
212
213	wxLongLongNative operator^(const wxLongLongNative& ll) const
214	{ return wxLongLongNative(m_ll ^ ll.m_ll); }
215	wxLongLongNative& operator^=(const wxLongLongNative& ll)
216	{ m_ll ^= ll.m_ll; return *this; }
217
b76b015e	218	// multiplication/division
8b81872f VZ	219	wxLongLongNative operator*(const wxLongLongNative& ll) const
8b81872f VZ	220	{ return wxLongLongNative(m_ll * ll.m_ll); }
2f02cb89 VZ	221	wxLongLongNative operator*(long l) const
2f02cb89 VZ	222	{ return wxLongLongNative(m_ll * l); }
8b81872f VZ	223	wxLongLongNative& operator*=(const wxLongLongNative& ll)
8b81872f VZ	224	{ m_ll = ll.m_ll; return this; }
2f02cb89 VZ	225	wxLongLongNative& operator*=(long l)
2f02cb89 VZ	226	{ m_ll = l; return this; }
8b81872f VZ	227
	228	wxLongLongNative operator/(const wxLongLongNative& ll) const
	229	{ return wxLongLongNative(m_ll / ll.m_ll); }
b76b015e VZ	230	wxLongLongNative operator/(long l) const
b76b015e VZ	231	{ return wxLongLongNative(m_ll / l); }
8b81872f VZ	232	wxLongLongNative& operator/=(const wxLongLongNative& ll)
8b81872f VZ	233	{ m_ll /= ll.m_ll; return *this; }
2f02cb89 VZ	234	wxLongLongNative& operator/=(long l)
2f02cb89 VZ	235	{ m_ll /= l; return *this; }
8b81872f VZ	236
	237	wxLongLongNative operator%(const wxLongLongNative& ll) const
	238	{ return wxLongLongNative(m_ll % ll.m_ll); }
b76b015e VZ	239	wxLongLongNative operator%(long l) const
b76b015e VZ	240	{ return wxLongLongNative(m_ll % l); }
8b81872f VZ	241
	242	// comparison
	243	bool operator==(const wxLongLongNative& ll) const
	244	{ return m_ll == ll.m_ll; }
b76b015e VZ	245	bool operator==(long l) const
b76b015e VZ	246	{ return m_ll == l; }
8b81872f VZ	247	bool operator!=(const wxLongLongNative& ll) const
8b81872f VZ	248	{ return m_ll != ll.m_ll; }
b76b015e VZ	249	bool operator!=(long l) const
b76b015e VZ	250	{ return m_ll != l; }
8b81872f VZ	251	bool operator<(const wxLongLongNative& ll) const
8b81872f VZ	252	{ return m_ll < ll.m_ll; }
b76b015e VZ	253	bool operator<(long l) const
b76b015e VZ	254	{ return m_ll < l; }
8b81872f VZ	255	bool operator>(const wxLongLongNative& ll) const
8b81872f VZ	256	{ return m_ll > ll.m_ll; }
b76b015e VZ	257	bool operator>(long l) const
b76b015e VZ	258	{ return m_ll > l; }
8b81872f VZ	259	bool operator<=(const wxLongLongNative& ll) const
8b81872f VZ	260	{ return m_ll <= ll.m_ll; }
b76b015e VZ	261	bool operator<=(long l) const
b76b015e VZ	262	{ return m_ll <= l; }
8b81872f VZ	263	bool operator>=(const wxLongLongNative& ll) const
8b81872f VZ	264	{ return m_ll >= ll.m_ll; }
b76b015e VZ	265	bool operator>=(long l) const
b76b015e VZ	266	{ return m_ll >= l; }
8b81872f VZ	267
	268	// miscellaneous
	269	// conversion to byte array: returns a pointer to static buffer!
	270	void *asArray() const;
	271
fcc3d7cb	272	#if wxUSE_STD_IOSTREAM
8b81872f	273	// input/output
162b0c3b	274	friend ostream& operator<<(ostream&, const wxLongLongNative&);
fcc3d7cb	275	#endif
8b81872f VZ	276
	277	private:
	278	wxLongLong_t m_ll;
	279	};
	280
	281	#endif // wxUSE_LONGLONG_NATIVE
	282
	283	#if wxUSE_LONGLONG_WX
	284
	285	class WXDLLEXPORT wxLongLongWx
	286	{
	287	public:
	288	// ctors
	289	// default ctor initializes to 0
	290	wxLongLongWx() { m_lo = m_hi = 0; }
	291	// from long
	292	wxLongLongWx(long l)
	293	{ m_lo = l; m_hi = (l < 0 ? -1l : 0l); }
	294	// from 2 longs
	295	wxLongLongWx(long hi, unsigned long lo)
	296	{ m_hi = hi; m_lo = lo; }
	297
	298	// default copy ctor is ok in both cases
	299
	300	// no dtor
	301
	302	// assignment operators
	303	// from long
	304	wxLongLongWx& operator=(long l)
	305	{ m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
	306	// can't have assignment operator from 2 longs
	307
	308	// accessors
	309	// get high part
	310	long GetHi() const { return m_hi; }
	311	// get low part
	312	unsigned long GetLo() const { return m_lo; }
	313
	314	// operations
	315	// addition
	316	wxLongLongWx operator+(const wxLongLongWx& ll) const;
	317	wxLongLongWx& operator+=(const wxLongLongWx& ll);
	318	wxLongLongWx operator+(long l) const;
	319	wxLongLongWx& operator+=(long l);
	320
	321	// pre increment operator
	322	wxLongLongWx& operator++();
	323
	324	// post increment operator
	325	wxLongLongWx& operator++(int);
	326
	327	// negation operator
	328	wxLongLongWx operator-() const;
	329
	330	// subraction
	331	wxLongLongWx operator-(const wxLongLongWx& ll) const;
	332	wxLongLongWx& operator-=(const wxLongLongWx& ll);
	333
	334	// pre decrement operator
	335	wxLongLongWx& operator--();
	336
	337	// post decrement operator
	338	wxLongLongWx& operator--(int);
	339
340	// shifts
341	// left shift
342	wxLongLongWx operator<<(int shift) const;
343	wxLongLongWx& operator<<=(int shift);
344
345	// right shift
346	wxLongLongWx operator>>(int shift) const;
347	wxLongLongWx& operator>>=(int shift);
348
349	// bitwise operators
350	wxLongLongWx operator&(const wxLongLongWx& ll) const;
351	wxLongLongWx& operator&=(const wxLongLongWx& ll);
352	wxLongLongWx operator\|(const wxLongLongWx& ll) const;
353	wxLongLongWx& operator\|=(const wxLongLongWx& ll);
354	wxLongLongWx operator^(const wxLongLongWx& ll) const;
355	wxLongLongWx& operator^=(const wxLongLongWx& ll);
356	wxLongLongWx operator~() const;
357
358	// comparison
359	bool operator==(const wxLongLongWx& ll) const;
360	bool operator!=(const wxLongLongWx& ll) const;
361	bool operator<(const wxLongLongWx& ll) const;
362	bool operator>(const wxLongLongWx& ll) const;
363	bool operator<=(const wxLongLongWx& ll) const;
364	bool operator>=(const wxLongLongWx& ll) const;
365
366	// multiplication
367	wxLongLongWx operator*(const wxLongLongWx& ll) const;
368	wxLongLongWx& operator*=(const wxLongLongWx& ll);
369	void *asArray(void) const;
370
371	// division
372	void Divide(const wxLongLongWx& divisor,
373	wxLongLongWx& quotient,
374	wxLongLongWx& remainder) const;
375
fcc3d7cb	376	#if wxUSE_STD_IOSTREAM
8b81872f	377	// input/output
162b0c3b	378	friend ostream& operator<<(ostream&, const wxLongLongWx&);
fcc3d7cb	379	#endif // wxUSE_STD_IOSTREAM
8b81872f VZ	380
	381	private:
	382	// long is at least 32 bits, so represent our 64bit number as 2 longs
	383
	384	long m_hi; // signed bit is in the high part
	385	unsigned long m_lo;
	386	};
	387
	388	#endif // wxUSE_LONGLONG_WX
	389
	390	#endif // _WX_LONGLONG_H