/////////////////////////////////////////////////////////////////////////////
// Name: wx/longlong.h
// Purpose: Legacy support for 64-bit integers predating universal long
// long availability
// Author: Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
// Created: 10.02.99
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LONGLONG_H
#define _WX_LONGLONG_H
#include "wx/defs.h"
#include "wx/iosfwrap.h"
#include "wx/string.h"
#include <limits.h> // for LONG_MAX
#if wxUSE_STREAMS
class WXDLLIMPEXP_FWD_BASE wxTextOutputStream;
class WXDLLIMPEXP_FWD_BASE wxTextInputStream;
#endif
class WXDLLIMPEXP_FWD_BASE wxULongLong;
class WXDLLIMPEXP_BASE wxWARN_UNUSED wxLongLong
{
public:
// ctors
// default ctor initializes to 0
wxLongLong() : m_ll(0) { }
// from long long
wxLongLong(wxLongLong_t ll) : m_ll(ll) { }
// from 2 longs
wxLongLong(wxInt32 hi, wxUint32 lo)
{
// cast first to avoid precision loss and use unsigned shift to avoid
// undefined behaviour if the high part is negative (and then cast
// again to avoid warning about the possible sign change)
m_ll = (wxLongLong_t)(((wxULongLong_t) hi) << 32);
m_ll |= (wxLongLong_t) lo;
}
// default copy ctor is ok
// no dtor
// assignment operators
// from native 64 bit integer
#ifndef wxLongLongIsLong
wxLongLong& operator=(wxLongLong_t ll)
{ m_ll = ll; return *this; }
wxLongLong& operator=(wxULongLong_t ll)
{ m_ll = ll; return *this; }
#endif // !wxLongLong
wxLongLong& operator=(const wxULongLong &ll);
wxLongLong& operator=(int l)
{ m_ll = l; return *this; }
wxLongLong& operator=(long l)
{ m_ll = l; return *this; }
wxLongLong& operator=(unsigned int l)
{ m_ll = l; return *this; }
wxLongLong& operator=(unsigned long l)
{ m_ll = l; 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
wxLongLong& Assign(double d)
{ m_ll = (wxLongLong_t)d; return *this; }
// assignment operators from wxLongLong is ok
// accessors
// get high part
wxInt32 GetHi() const
{ return wx_truncate_cast(wxInt32, m_ll >> 32); }
// get low part
wxUint32 GetLo() const
{ return wx_truncate_cast(wxUint32, m_ll); }
// get absolute value
wxLongLong Abs() const { return wxLongLong(*this).Abs(); }
wxLongLong& 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 debug mode (only!)
long ToLong() const
{
// This assert is useless if long long is the same as long (which is
// the case under the standard Unix LP64 model).
#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
wxT("wxLongLong to long conversion loss of precision") );
#endif
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; }
// operations
// addition
wxLongLong operator+(const wxLongLong& ll) const
{ return wxLongLong(m_ll + ll.m_ll); }
wxLongLong& operator+=(const wxLongLong& ll)
{ m_ll += ll.m_ll; return *this; }
friend wxLongLong operator+(long l, const wxLongLong& ll)
{ return ll + l; }
wxLongLong operator+(const wxLongLong_t ll) const
{ return wxLongLong(m_ll + ll); }
wxLongLong& operator+=(const wxLongLong_t ll)
{ m_ll += ll; return *this; }
// pre increment
wxLongLong& operator++()
{ m_ll++; return *this; }
// post increment
wxLongLong operator++(int)
{ wxLongLong value(*this); m_ll++; return value; }
// negation operator
wxLongLong operator-() const
{ return wxLongLong(-m_ll); }
wxLongLong& Negate() { m_ll = -m_ll; return *this; }
// subtraction
wxLongLong operator-(const wxLongLong& ll) const
{ return wxLongLong(m_ll - ll.m_ll); }
wxLongLong& operator-=(const wxLongLong& ll)
{ m_ll -= ll.m_ll; return *this; }
friend wxLongLong operator-(long l, const wxLongLong& ll)
{
return wxLongLong(l) - ll;
}
wxLongLong operator-(const wxLongLong_t ll) const
{ return wxLongLong(m_ll - ll); }
wxLongLong& operator-=(const wxLongLong_t ll)
{ m_ll -= ll; return *this; }
// pre decrement
wxLongLong& operator--()
{ m_ll--; return *this; }
// post decrement
wxLongLong operator--(int)
{ wxLongLong value(*this); m_ll--; return value; }
// shifts
// left shift
wxLongLong operator<<(int shift) const
{ return wxLongLong(m_ll << shift); }
wxLongLong& operator<<=(int shift)
{ m_ll <<= shift; return *this; }
// right shift
wxLongLong operator>>(int shift) const
{ return wxLongLong(m_ll >> shift); }
wxLongLong& operator>>=(int shift)
{ m_ll >>= shift; return *this; }
// bitwise operators
wxLongLong operator&(const wxLongLong& ll) const
{ return wxLongLong(m_ll & ll.m_ll); }
wxLongLong& operator&=(const wxLongLong& ll)
{ m_ll &= ll.m_ll; return *this; }
wxLongLong operator|(const wxLongLong& ll) const
{ return wxLongLong(m_ll | ll.m_ll); }
wxLongLong& operator|=(const wxLongLong& ll)
{ m_ll |= ll.m_ll; return *this; }
wxLongLong operator^(const wxLongLong& ll) const
{ return wxLongLong(m_ll ^ ll.m_ll); }
wxLongLong& operator^=(const wxLongLong& ll)
{ m_ll ^= ll.m_ll; return *this; }
// multiplication/division
wxLongLong operator*(const wxLongLong& ll) const
{ return wxLongLong(m_ll * ll.m_ll); }
wxLongLong operator*(long l) const
{ return wxLongLong(m_ll * l); }
wxLongLong& operator*=(const wxLongLong& ll)
{ m_ll *= ll.m_ll; return *this; }
wxLongLong& operator*=(long l)
{ m_ll *= l; return *this; }
wxLongLong operator/(const wxLongLong& ll) const
{ return wxLongLong(m_ll / ll.m_ll); }
wxLongLong operator/(long l) const
{ return wxLongLong(m_ll / l); }
wxLongLong& operator/=(const wxLongLong& ll)
{ m_ll /= ll.m_ll; return *this; }
wxLongLong& operator/=(long l)
{ m_ll /= l; return *this; }
wxLongLong operator%(const wxLongLong& ll) const
{ return wxLongLong(m_ll % ll.m_ll); }
wxLongLong operator%(long l) const
{ return wxLongLong(m_ll % l); }
// comparison
bool operator==(const wxLongLong& ll) const
{ return m_ll == ll.m_ll; }
bool operator==(long l) const
{ return m_ll == l; }
bool operator!=(const wxLongLong& ll) const
{ return m_ll != ll.m_ll; }
bool operator!=(long l) const
{ return m_ll != l; }
bool operator<(const wxLongLong& ll) const
{ return m_ll < ll.m_ll; }
bool operator<(long l) const
{ return m_ll < l; }
bool operator>(const wxLongLong& ll) const
{ return m_ll > ll.m_ll; }
bool operator>(long l) const
{ return m_ll > l; }
bool operator<=(const wxLongLong& ll) const
{ return m_ll <= ll.m_ll; }
bool operator<=(long l) const
{ return m_ll <= l; }
bool operator>=(const wxLongLong& ll) const
{ return m_ll >= ll.m_ll; }
bool operator>=(long l) const
{ return m_ll >= l; }
friend bool operator<(long l, const wxLongLong& ll) { return ll > l; }
friend bool operator>(long l, const wxLongLong& ll) { return ll < l; }
friend bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
friend bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
friend bool operator==(long l, const wxLongLong& ll) { return ll == l; }
friend bool operator!=(long l, const wxLongLong& ll) { return ll != l; }
// miscellaneous
// return the string representation of this number
wxString ToString() const
{
return wxString::Format(wxASCII_STR("%" wxLongLongFmtSpec "d"), m_ll);
}
// conversion to byte array: returns a pointer to static buffer!
void *asArray() const;
#if wxUSE_STD_IOSTREAM
// input/output
friend WXDLLIMPEXP_BASE
std::ostream& operator<<(std::ostream&, const wxLongLong&);
#endif
friend WXDLLIMPEXP_BASE
wxString& operator<<(wxString&, const wxLongLong&);
#if wxUSE_STREAMS
friend WXDLLIMPEXP_BASE
class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLong&);
friend WXDLLIMPEXP_BASE
class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLong&);
#endif
private:
wxLongLong_t m_ll;
};
class WXDLLIMPEXP_BASE wxWARN_UNUSED wxULongLong
{
public:
// ctors
// default ctor initializes to 0
wxULongLong() : m_ll(0) { }
// from long long
wxULongLong(wxULongLong_t ll) : m_ll(ll) { }
// from 2 longs
wxULongLong(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;
}
// default copy ctor is ok
// no dtor
// assignment operators
// from native 64 bit integer
#ifndef wxLongLongIsLong
wxULongLong& operator=(wxULongLong_t ll)
{ m_ll = ll; return *this; }
wxULongLong& operator=(wxLongLong_t ll)
{ m_ll = ll; return *this; }
#endif // !wxLongLong
wxULongLong& operator=(int l)
{ m_ll = l; return *this; }
wxULongLong& operator=(long l)
{ m_ll = l; return *this; }
wxULongLong& operator=(unsigned int l)
{ m_ll = l; return *this; }
wxULongLong& operator=(unsigned long l)
{ m_ll = l; return *this; }
wxULongLong& operator=(const wxLongLong &ll)
{ m_ll = ll.GetValue(); return *this; }
// assignment operators from wxULongLong 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 <= ULONG_MAX,
wxT("wxULongLong to long conversion loss of precision") );
return wx_truncate_cast(unsigned long, m_ll);
}
// convert to double
double ToDouble() const { return wx_truncate_cast(double, m_ll); }
// operations
// addition
wxULongLong operator+(const wxULongLong& ll) const
{ return wxULongLong(m_ll + ll.m_ll); }
wxULongLong& operator+=(const wxULongLong& ll)
{ m_ll += ll.m_ll; return *this; }
friend wxULongLong operator+(unsigned long l, const wxULongLong& ull)
{ return ull + l; }
wxULongLong operator+(const wxULongLong_t ll) const
{ return wxULongLong(m_ll + ll); }
wxULongLong& operator+=(const wxULongLong_t ll)
{ m_ll += ll; return *this; }
// pre increment
wxULongLong& operator++()
{ m_ll++; return *this; }
// post increment
wxULongLong operator++(int)
{ wxULongLong value(*this); m_ll++; return value; }
// subtraction
wxULongLong operator-(const wxULongLong& ll) const
{ return wxULongLong(m_ll - ll.m_ll); }
wxULongLong& operator-=(const wxULongLong& ll)
{ m_ll -= ll.m_ll; return *this; }
friend wxULongLong operator-(unsigned long l, const wxULongLong& ull)
{
return wxULongLong(l - ull.m_ll);
}
wxULongLong operator-(const wxULongLong_t ll) const
{ return wxULongLong(m_ll - ll); }
wxULongLong& operator-=(const wxULongLong_t ll)
{ m_ll -= ll; return *this; }
// pre decrement
wxULongLong& operator--()
{ m_ll--; return *this; }
// post decrement
wxULongLong operator--(int)
{ wxULongLong value(*this); m_ll--; return value; }
// shifts
// left shift
wxULongLong operator<<(int shift) const
{ return wxULongLong(m_ll << shift); }
wxULongLong& operator<<=(int shift)
{ m_ll <<= shift; return *this; }
// right shift
wxULongLong operator>>(int shift) const
{ return wxULongLong(m_ll >> shift); }
wxULongLong& operator>>=(int shift)
{ m_ll >>= shift; return *this; }
// bitwise operators
wxULongLong operator&(const wxULongLong& ll) const
{ return wxULongLong(m_ll & ll.m_ll); }
wxULongLong& operator&=(const wxULongLong& ll)
{ m_ll &= ll.m_ll; return *this; }
wxULongLong operator|(const wxULongLong& ll) const
{ return wxULongLong(m_ll | ll.m_ll); }
wxULongLong& operator|=(const wxULongLong& ll)
{ m_ll |= ll.m_ll; return *this; }
wxULongLong operator^(const wxULongLong& ll) const
{ return wxULongLong(m_ll ^ ll.m_ll); }
wxULongLong& operator^=(const wxULongLong& ll)
{ m_ll ^= ll.m_ll; return *this; }
// multiplication/division
wxULongLong operator*(const wxULongLong& ll) const
{ return wxULongLong(m_ll * ll.m_ll); }
wxULongLong operator*(unsigned long l) const
{ return wxULongLong(m_ll * l); }
wxULongLong& operator*=(const wxULongLong& ll)
{ m_ll *= ll.m_ll; return *this; }
wxULongLong& operator*=(unsigned long l)
{ m_ll *= l; return *this; }
wxULongLong operator/(const wxULongLong& ll) const
{ return wxULongLong(m_ll / ll.m_ll); }
wxULongLong operator/(unsigned long l) const
{ return wxULongLong(m_ll / l); }
wxULongLong& operator/=(const wxULongLong& ll)
{ m_ll /= ll.m_ll; return *this; }
wxULongLong& operator/=(unsigned long l)
{ m_ll /= l; return *this; }
wxULongLong operator%(const wxULongLong& ll) const
{ return wxULongLong(m_ll % ll.m_ll); }
wxULongLong operator%(unsigned long l) const
{ return wxULongLong(m_ll % l); }
// comparison
bool operator==(const wxULongLong& ll) const
{ return m_ll == ll.m_ll; }
bool operator==(unsigned long l) const
{ return m_ll == l; }
bool operator!=(const wxULongLong& ll) const
{ return m_ll != ll.m_ll; }
bool operator!=(unsigned long l) const
{ return m_ll != l; }
bool operator<(const wxULongLong& ll) const
{ return m_ll < ll.m_ll; }
bool operator<(unsigned long l) const
{ return m_ll < l; }
bool operator>(const wxULongLong& ll) const
{ return m_ll > ll.m_ll; }
bool operator>(unsigned long l) const
{ return m_ll > l; }
bool operator<=(const wxULongLong& ll) const
{ return m_ll <= ll.m_ll; }
bool operator<=(unsigned long l) const
{ return m_ll <= l; }
bool operator>=(const wxULongLong& ll) const
{ return m_ll >= ll.m_ll; }
bool operator>=(unsigned long l) const
{ return m_ll >= l; }
friend bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
friend bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
friend bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
friend bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
friend bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
friend bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }
// miscellaneous
// return the string representation of this number
wxString ToString() const
{
return wxString::Format(wxASCII_STR("%" wxLongLongFmtSpec "u"), m_ll);
}
// conversion to byte array: returns a pointer to static buffer!
void *asArray() const;
#if wxUSE_STD_IOSTREAM
// input/output
friend WXDLLIMPEXP_BASE
std::ostream& operator<<(std::ostream&, const wxULongLong&);
#endif
friend WXDLLIMPEXP_BASE
wxString& operator<<(wxString&, const wxULongLong&);
#if wxUSE_STREAMS
friend WXDLLIMPEXP_BASE
class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLong&);
friend WXDLLIMPEXP_BASE
class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLong&);
#endif
private:
wxULongLong_t m_ll;
};
inline
wxLongLong& wxLongLong::operator=(const wxULongLong &ll)
{
m_ll = ll.GetValue();
return *this;
}
// ----------------------------------------------------------------------------
// Specialize numeric_limits<> for our long long wrapper classes.
// ----------------------------------------------------------------------------
#include <limits>
namespace std
{
template<> struct numeric_limits<wxLongLong> : numeric_limits<wxLongLong_t> {};
template<> struct numeric_limits<wxULongLong> : numeric_limits<wxULongLong_t> {};
} // namespace std
// ----------------------------------------------------------------------------
// Specialize wxArgNormalizer to allow using wxLongLong directly with wx pseudo
// vararg functions.
// ----------------------------------------------------------------------------
// Notice that this must be done here and not in wx/strvararg.h itself because
// we can't include wx/longlong.h from there as this header itself includes
// wx/string.h which includes wx/strvararg.h too, so to avoid the circular
// dependencies we can only do it here (or add another header just for this but
// it doesn't seem necessary).
#include "wx/strvararg.h"
template<>
struct wxFormatStringSpecifier<wxLongLong>
{
enum { value = wxFormatString::Arg_LongLongInt };
};
template<>
struct WXDLLIMPEXP_BASE wxArgNormalizer<wxLongLong>
{
wxArgNormalizer(wxLongLong value,
const wxFormatString *fmt, unsigned index)
: m_value(value)
{
wxASSERT_ARG_TYPE( fmt, index, wxFormatString::Arg_LongLongInt );
}
wxLongLong_t get() const { return m_value.GetValue(); }
wxLongLong m_value;
};
// Compatibility typedefs: these types were never supposed to be used outside
// of wx itself but nevertheless appear in the existing code, so define them to
// let it continue to build.
using wxLongLongNative = wxLongLong;
using wxULongLongNative = wxULongLong;
#endif // _WX_LONGLONG_H
