diff --git a/base/src/MANIFEST b/base/src/MANIFEST index c26f38284ecd..2cdd288700d8 100644 --- a/base/src/MANIFEST +++ b/base/src/MANIFEST @@ -20,3 +20,5 @@ nsUnitConversion.h nsIBaseStream.h nsIInputStream.h nsIOutputStream.h +nsInt64.h +nsTime.h diff --git a/base/src/Makefile b/base/src/Makefile index 788665215ce2..abe62bdf90c6 100644 --- a/base/src/Makefile +++ b/base/src/Makefile @@ -53,8 +53,10 @@ EXPORTS = \ nsITimerCallback.h \ nsIUnicharBuffer.h \ nsIUnicharInputStream.h \ + nsInt64.h \ nsRBTree.h \ nsString.h \ + nsTime.h \ nsVoidArray.h \ nsUnitConversion.h \ $(NULL) diff --git a/base/src/Makefile.in b/base/src/Makefile.in index 5dbfd2d2f98d..aaa13946490b 100644 --- a/base/src/Makefile.in +++ b/base/src/Makefile.in @@ -58,8 +58,10 @@ EXPORTS = \ nsITimerCallback.h \ nsIUnicharBuffer.h \ nsIUnicharInputStream.h \ + nsInt64.h \ nsRBTree.h \ nsString.h \ + nsTime.h \ nsVoidArray.h \ nsUnitConversion.h \ $(NULL) diff --git a/base/src/makefile.win b/base/src/makefile.win index 434ca1807cb9..615f99a79190 100644 --- a/base/src/makefile.win +++ b/base/src/makefile.win @@ -58,7 +58,8 @@ EXPORTS=nscore.h nsIArena.h nsIAtom.h nsIByteBuffer.h \ nsITimerCallback.h nsIUnicharBuffer.h nsRBTree.h \ nsIUnicharInputStream.h nsString.h nsVoidArray.h \ nsUnitConversion.h \ - nsIBaseStream.h nsIInputStream.h nsIOutputStream.h + nsIBaseStream.h nsIInputStream.h nsIOutputStream.h \ + nsInt64.h nsTime.h MODULE=raptor diff --git a/base/src/nsInt64.h b/base/src/nsInt64.h new file mode 100644 index 000000000000..3adc0df60edc --- /dev/null +++ b/base/src/nsInt64.h @@ -0,0 +1,335 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nsInt64_h__ +#define nsInt64_h__ + +#include "prlong.h" +#include "nscore.h" + +/** + * This class encapsulates full 64-bit integer functionality and + * provides simple arithmetic and conversion operations. + */ +class NS_BASE nsInt64 +{ + private: + PRInt64 mValue; + + public: + /** + * Construct a new 64-bit integer. + */ + nsInt64(void) : mValue(LL_ZERO) { + } + + /** + * Construct a new 64-bit integer from a 32-bit signed integer + */ + nsInt64(const PRInt32 aInt32) { + LL_I2L(mValue, aInt32); + } + + /** + * Construct a new 64-bit integer from a 32-bit unsigned integer + */ + nsInt64(const PRUint32 aUint32) { + LL_UI2L(mValue, aUint32); + } + + /** + * Construct a new 64-bit integer from a floating point value. + */ + nsInt64(const PRFloat64 aFloat64) { + LL_D2L(mValue, aFloat64); + } + + /** + * Construct a new 64-bit integer from a native 64-bit integer + */ + nsInt64(const PRInt64 aInt64) : mValue(aInt64) { + } + + /** + * Construct a new 64-bit integer from another 64-bit integer + */ + nsInt64(const nsInt64& aObject) : mValue(aObject.mValue) { + } + + // ~nsInt64(void) -- XXX destructor unnecessary + + /** + * Assign a 64-bit integer to another 64-bit integer + */ + const nsInt64& operator =(const nsInt64& aObject) { + mValue = aObject.mValue; + return *this; + } + + /** + * Convert a 64-bit integer to a signed 32-bit value + */ + operator PRInt32(void) const { + PRInt32 result; + LL_L2I(result, mValue); + return result; + } + + /** + * Convert a 64-bit integer to an unsigned 32-bit value + */ + operator PRUint32(void) const { + PRUint32 result; + LL_L2UI(result, mValue); + return result; + } + + /** + * Convert a 64-bit integer to a floating point value + */ + operator PRFloat64(void) const { + PRFloat64 result; + LL_L2D(result, mValue); + return result; + } + + /** + * Convert a 64-bit integer to a native 64-bit integer. + */ + operator PRInt64(void) const { + return mValue; + } + + /** + * Perform unary negation on a 64-bit integer. + */ + const nsInt64 operator -(void) { + nsInt64 result; + LL_NEG(result.mValue, mValue); + return result; + } + + // Arithmetic operators + friend const nsInt64 operator +(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator -(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator *(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator /(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator %(const nsInt64& aObject1, const nsInt64& aObject2); + + /** + * Increment a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator +=(const nsInt64& aObject) { + LL_ADD(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Decrement a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator -=(const nsInt64& aObject) { + LL_SUB(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Multiply a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator *=(const nsInt64& aObject) { + LL_MUL(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Divide a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator /=(const nsInt64& aObject) { + LL_DIV(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Compute the modulus of a 64-bit integer to a 64-bit value. + */ + nsInt64& operator %=(const nsInt64& aObject) { + LL_MOD(mValue, mValue, aObject.mValue); + return *this; + } + + // Comparison operators + friend PRBool operator ==(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator !=(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator >(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator >=(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator <(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator <=(const nsInt64& aObject1, const nsInt64& aObject2); + + // Bitwise operators + friend const nsInt64 operator &(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator |(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator ^(const nsInt64& aObject1, const nsInt64& aObject2); + + /** + * Compute the bitwise NOT of a 64-bit integer + */ + const nsInt64 operator ~(void) { + nsInt64 result; + LL_NOT(result.mValue, mValue); + return result; + } + + /** + * Compute the bitwise AND with another 64-bit integer + */ + nsInt64& operator &=(const nsInt64& aObject) { + LL_AND(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Compute the bitwise OR with another 64-bit integer + */ + nsInt64& operator |=(const nsInt64& aObject) { + LL_OR(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Compute the bitwise XOR with another 64-bit integer + */ + nsInt64& operator ^=(const nsInt64& aObject) { + LL_XOR(mValue, mValue, aObject.mValue); + return *this; + } +}; + + +/** + * Add two 64-bit integers. + */ +const nsInt64 +operator +(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) += aObject2; +} + +/** + * Subtract one 64-bit integer from another. + */ +inline const nsInt64 +operator -(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) -= aObject2; +} + +/** + * Multiply two 64-bit integers + */ +inline const nsInt64 +operator *(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) *= aObject2; +} + +/** + * Divide one 64-bit integer by another + */ +inline const nsInt64 +operator /(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) /= aObject2; +} + +/** + * Compute the modulus of two 64-bit integers + */ +inline const nsInt64 +operator %(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) %= aObject2; +} + +/** + * Determine if two 64-bit integers are equal + */ +inline PRBool +operator ==(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_EQ(aObject1.mValue, aObject2.mValue); +} + +/** + * Determine if two 64-bit integers are not equal + */ +inline PRBool +operator !=(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_NE(aObject1.mValue, aObject2.mValue); +} + +/** + * Determine if one 64-bit integer is strictly greater than another, using signed values + */ +inline PRBool +operator >(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, >, aObject2.mValue); +} + +/** + * Determine if one 64-bit integer is greater than or equal to another, using signed values + */ +inline PRBool +operator >=(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, >=, aObject2.mValue); +} + +/** + * Determine if one 64-bit integer is strictly less than another, using signed values + */ +inline PRBool +operator <(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, <, aObject2.mValue); +} + +/** + * Determine if one 64-bit integers is less than or equal to another, using signed values + */ +inline PRBool +operator <=(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, <=, aObject2.mValue); +} + +/** + * Perform a bitwise AND of two 64-bit integers + */ +inline const nsInt64 +operator &(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) &= aObject2; +} + +/** + * Perform a bitwise OR of two 64-bit integers + */ +inline const nsInt64 +operator |(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) |= aObject2; +} + +/** + * Perform a bitwise XOR of two 64-bit integers + */ +inline const nsInt64 +operator ^(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) ^= aObject2; +} + + +#endif // nsInt64_h__ diff --git a/base/src/nsTime.h b/base/src/nsTime.h new file mode 100644 index 000000000000..d4c8358178f5 --- /dev/null +++ b/base/src/nsTime.h @@ -0,0 +1,179 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nsTime_h__ +#define nsTime_h__ + +#include "prtime.h" +#include "nsInt64.h" +#include "nscore.h" + +/** + * This class encapsulates full 64-bit time functionality and + * provides simple arithmetic and conversion operations. + */ +class NS_BASE nsTime +{ +private: + nsInt64 mValue; + +public: + /** + * Construct the current time. + */ + nsTime(void) : mValue(PR_Now()) { + } + + /** + * Construct a time from a PRTime. + */ + nsTime(const PRTime aTime) : mValue(aTime) { + } + + /** + * Construct a time from a 64-bit value. + */ + nsTime(const nsInt64& aTime) : mValue(aTime) { + } + + /** + * Construct a time from another time. + */ + nsTime(const nsTime& aTime) : mValue(aTime.mValue) { + } + + // ~nsTime(void) -- XXX destructor unnecessary + + /** + * Assign one time to another. + */ + const nsTime& operator =(const nsTime& aTime) { + mValue = aTime.mValue; + return *this; + } + + /** + * Convert a nsTime object to a PRTime + */ + operator PRTime(void) const { + return mValue; + } + + /** + * Subtract a 64-bit interval from a time. + */ + nsTime& operator -=(const nsInt64& aInterval) { + mValue -= aInterval; + return *this; + } + + /** + * Add a 64-bit interval to a time. + */ + nsTime& operator +=(const nsInt64& aInterval) { + mValue += aInterval; + return *this; + } + + // Arithmetic operators + friend const nsTime operator +(const nsTime& aTime, const nsInt64& aInterval); + friend const nsTime operator -(const nsTime& aTime, const nsInt64& aInterval); + friend const nsInt64 operator -(const nsTime& aTime1, const nsTime& aTime2); + + // Comparison operators + friend const PRBool operator ==(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator !=(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator <(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator <=(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator >(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator >=(const nsTime& aTime1, const nsTime& aTime2); +}; + +/** + * Binary addition to add a 64-bit interval to a time. + */ +inline const nsTime +operator +(const nsTime& aTime, const nsInt64& aInterval) { + return nsTime(aTime.mValue + aInterval); +} + +/** + * Binary subtraction to subtract a 64-bit interval to a time. + */ +inline const nsTime +operator -(const nsTime& aTime, const nsInt64& aInterval) { + return nsTime(aTime.mValue - aInterval); +} + +/** + * Binary subtraction to compute an interval from the difference of two times. + */ +inline const nsInt64 +operator -(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue - aTime2.mValue; +} + +/** + * Determine if two times are equal + */ +inline const PRBool +operator ==(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue == aTime2.mValue; +} + +/** + * Determine if two times are different + */ +inline const PRBool +operator !=(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue != aTime2.mValue; +} + +/** + * Determine if one time is strictly less than another + */ +inline const PRBool +operator <(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue < aTime2.mValue; +} + +/** + * Determine if one time is less than or equal to another + */ +inline const PRBool +operator <=(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue <= aTime2.mValue; +} + +/** + * Determine if one time is strictly greater than another + */ +inline const PRBool +operator >(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue > aTime2.mValue; +} + +/** + * Determine if one time is greater than or equal to another + */ +inline const PRBool +operator >=(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue >= aTime2.mValue; +} + +#endif // nsTime_h__ diff --git a/xpcom/ds/nsInt64.h b/xpcom/ds/nsInt64.h new file mode 100644 index 000000000000..3adc0df60edc --- /dev/null +++ b/xpcom/ds/nsInt64.h @@ -0,0 +1,335 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nsInt64_h__ +#define nsInt64_h__ + +#include "prlong.h" +#include "nscore.h" + +/** + * This class encapsulates full 64-bit integer functionality and + * provides simple arithmetic and conversion operations. + */ +class NS_BASE nsInt64 +{ + private: + PRInt64 mValue; + + public: + /** + * Construct a new 64-bit integer. + */ + nsInt64(void) : mValue(LL_ZERO) { + } + + /** + * Construct a new 64-bit integer from a 32-bit signed integer + */ + nsInt64(const PRInt32 aInt32) { + LL_I2L(mValue, aInt32); + } + + /** + * Construct a new 64-bit integer from a 32-bit unsigned integer + */ + nsInt64(const PRUint32 aUint32) { + LL_UI2L(mValue, aUint32); + } + + /** + * Construct a new 64-bit integer from a floating point value. + */ + nsInt64(const PRFloat64 aFloat64) { + LL_D2L(mValue, aFloat64); + } + + /** + * Construct a new 64-bit integer from a native 64-bit integer + */ + nsInt64(const PRInt64 aInt64) : mValue(aInt64) { + } + + /** + * Construct a new 64-bit integer from another 64-bit integer + */ + nsInt64(const nsInt64& aObject) : mValue(aObject.mValue) { + } + + // ~nsInt64(void) -- XXX destructor unnecessary + + /** + * Assign a 64-bit integer to another 64-bit integer + */ + const nsInt64& operator =(const nsInt64& aObject) { + mValue = aObject.mValue; + return *this; + } + + /** + * Convert a 64-bit integer to a signed 32-bit value + */ + operator PRInt32(void) const { + PRInt32 result; + LL_L2I(result, mValue); + return result; + } + + /** + * Convert a 64-bit integer to an unsigned 32-bit value + */ + operator PRUint32(void) const { + PRUint32 result; + LL_L2UI(result, mValue); + return result; + } + + /** + * Convert a 64-bit integer to a floating point value + */ + operator PRFloat64(void) const { + PRFloat64 result; + LL_L2D(result, mValue); + return result; + } + + /** + * Convert a 64-bit integer to a native 64-bit integer. + */ + operator PRInt64(void) const { + return mValue; + } + + /** + * Perform unary negation on a 64-bit integer. + */ + const nsInt64 operator -(void) { + nsInt64 result; + LL_NEG(result.mValue, mValue); + return result; + } + + // Arithmetic operators + friend const nsInt64 operator +(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator -(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator *(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator /(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator %(const nsInt64& aObject1, const nsInt64& aObject2); + + /** + * Increment a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator +=(const nsInt64& aObject) { + LL_ADD(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Decrement a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator -=(const nsInt64& aObject) { + LL_SUB(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Multiply a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator *=(const nsInt64& aObject) { + LL_MUL(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Divide a 64-bit integer by a 64-bit integer amount. + */ + nsInt64& operator /=(const nsInt64& aObject) { + LL_DIV(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Compute the modulus of a 64-bit integer to a 64-bit value. + */ + nsInt64& operator %=(const nsInt64& aObject) { + LL_MOD(mValue, mValue, aObject.mValue); + return *this; + } + + // Comparison operators + friend PRBool operator ==(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator !=(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator >(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator >=(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator <(const nsInt64& aObject1, const nsInt64& aObject2); + friend PRBool operator <=(const nsInt64& aObject1, const nsInt64& aObject2); + + // Bitwise operators + friend const nsInt64 operator &(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator |(const nsInt64& aObject1, const nsInt64& aObject2); + friend const nsInt64 operator ^(const nsInt64& aObject1, const nsInt64& aObject2); + + /** + * Compute the bitwise NOT of a 64-bit integer + */ + const nsInt64 operator ~(void) { + nsInt64 result; + LL_NOT(result.mValue, mValue); + return result; + } + + /** + * Compute the bitwise AND with another 64-bit integer + */ + nsInt64& operator &=(const nsInt64& aObject) { + LL_AND(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Compute the bitwise OR with another 64-bit integer + */ + nsInt64& operator |=(const nsInt64& aObject) { + LL_OR(mValue, mValue, aObject.mValue); + return *this; + } + + /** + * Compute the bitwise XOR with another 64-bit integer + */ + nsInt64& operator ^=(const nsInt64& aObject) { + LL_XOR(mValue, mValue, aObject.mValue); + return *this; + } +}; + + +/** + * Add two 64-bit integers. + */ +const nsInt64 +operator +(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) += aObject2; +} + +/** + * Subtract one 64-bit integer from another. + */ +inline const nsInt64 +operator -(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) -= aObject2; +} + +/** + * Multiply two 64-bit integers + */ +inline const nsInt64 +operator *(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) *= aObject2; +} + +/** + * Divide one 64-bit integer by another + */ +inline const nsInt64 +operator /(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) /= aObject2; +} + +/** + * Compute the modulus of two 64-bit integers + */ +inline const nsInt64 +operator %(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) %= aObject2; +} + +/** + * Determine if two 64-bit integers are equal + */ +inline PRBool +operator ==(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_EQ(aObject1.mValue, aObject2.mValue); +} + +/** + * Determine if two 64-bit integers are not equal + */ +inline PRBool +operator !=(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_NE(aObject1.mValue, aObject2.mValue); +} + +/** + * Determine if one 64-bit integer is strictly greater than another, using signed values + */ +inline PRBool +operator >(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, >, aObject2.mValue); +} + +/** + * Determine if one 64-bit integer is greater than or equal to another, using signed values + */ +inline PRBool +operator >=(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, >=, aObject2.mValue); +} + +/** + * Determine if one 64-bit integer is strictly less than another, using signed values + */ +inline PRBool +operator <(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, <, aObject2.mValue); +} + +/** + * Determine if one 64-bit integers is less than or equal to another, using signed values + */ +inline PRBool +operator <=(const nsInt64& aObject1, const nsInt64& aObject2) { + return LL_CMP(aObject1.mValue, <=, aObject2.mValue); +} + +/** + * Perform a bitwise AND of two 64-bit integers + */ +inline const nsInt64 +operator &(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) &= aObject2; +} + +/** + * Perform a bitwise OR of two 64-bit integers + */ +inline const nsInt64 +operator |(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) |= aObject2; +} + +/** + * Perform a bitwise XOR of two 64-bit integers + */ +inline const nsInt64 +operator ^(const nsInt64& aObject1, const nsInt64& aObject2) { + return nsInt64(aObject1) ^= aObject2; +} + + +#endif // nsInt64_h__ diff --git a/xpcom/ds/nsTime.h b/xpcom/ds/nsTime.h new file mode 100644 index 000000000000..d4c8358178f5 --- /dev/null +++ b/xpcom/ds/nsTime.h @@ -0,0 +1,179 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nsTime_h__ +#define nsTime_h__ + +#include "prtime.h" +#include "nsInt64.h" +#include "nscore.h" + +/** + * This class encapsulates full 64-bit time functionality and + * provides simple arithmetic and conversion operations. + */ +class NS_BASE nsTime +{ +private: + nsInt64 mValue; + +public: + /** + * Construct the current time. + */ + nsTime(void) : mValue(PR_Now()) { + } + + /** + * Construct a time from a PRTime. + */ + nsTime(const PRTime aTime) : mValue(aTime) { + } + + /** + * Construct a time from a 64-bit value. + */ + nsTime(const nsInt64& aTime) : mValue(aTime) { + } + + /** + * Construct a time from another time. + */ + nsTime(const nsTime& aTime) : mValue(aTime.mValue) { + } + + // ~nsTime(void) -- XXX destructor unnecessary + + /** + * Assign one time to another. + */ + const nsTime& operator =(const nsTime& aTime) { + mValue = aTime.mValue; + return *this; + } + + /** + * Convert a nsTime object to a PRTime + */ + operator PRTime(void) const { + return mValue; + } + + /** + * Subtract a 64-bit interval from a time. + */ + nsTime& operator -=(const nsInt64& aInterval) { + mValue -= aInterval; + return *this; + } + + /** + * Add a 64-bit interval to a time. + */ + nsTime& operator +=(const nsInt64& aInterval) { + mValue += aInterval; + return *this; + } + + // Arithmetic operators + friend const nsTime operator +(const nsTime& aTime, const nsInt64& aInterval); + friend const nsTime operator -(const nsTime& aTime, const nsInt64& aInterval); + friend const nsInt64 operator -(const nsTime& aTime1, const nsTime& aTime2); + + // Comparison operators + friend const PRBool operator ==(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator !=(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator <(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator <=(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator >(const nsTime& aTime1, const nsTime& aTime2); + friend const PRBool operator >=(const nsTime& aTime1, const nsTime& aTime2); +}; + +/** + * Binary addition to add a 64-bit interval to a time. + */ +inline const nsTime +operator +(const nsTime& aTime, const nsInt64& aInterval) { + return nsTime(aTime.mValue + aInterval); +} + +/** + * Binary subtraction to subtract a 64-bit interval to a time. + */ +inline const nsTime +operator -(const nsTime& aTime, const nsInt64& aInterval) { + return nsTime(aTime.mValue - aInterval); +} + +/** + * Binary subtraction to compute an interval from the difference of two times. + */ +inline const nsInt64 +operator -(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue - aTime2.mValue; +} + +/** + * Determine if two times are equal + */ +inline const PRBool +operator ==(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue == aTime2.mValue; +} + +/** + * Determine if two times are different + */ +inline const PRBool +operator !=(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue != aTime2.mValue; +} + +/** + * Determine if one time is strictly less than another + */ +inline const PRBool +operator <(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue < aTime2.mValue; +} + +/** + * Determine if one time is less than or equal to another + */ +inline const PRBool +operator <=(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue <= aTime2.mValue; +} + +/** + * Determine if one time is strictly greater than another + */ +inline const PRBool +operator >(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue > aTime2.mValue; +} + +/** + * Determine if one time is greater than or equal to another + */ +inline const PRBool +operator >=(const nsTime& aTime1, const nsTime& aTime2) { + return aTime1.mValue >= aTime2.mValue; +} + +#endif // nsTime_h__