You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
602 lines
20 KiB
602 lines
20 KiB
/***************************************************************************
|
|
mymoneymoney.h
|
|
-------------------
|
|
copyright : (C) 2000-2002 by Michael Edwardes
|
|
email : mte@users.sourceforge.net
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
#ifndef _MYMONEYMONEY_H
|
|
#define _MYMONEYMONEY_H
|
|
|
|
#include <stdlib.h>
|
|
|
|
#ifndef HAVE_ATOLL
|
|
# ifdef HAVE_STRTOLL
|
|
# define atoll(a) strtoll(a, 0, 10)
|
|
# endif
|
|
#endif
|
|
|
|
#include <cmath>
|
|
|
|
#ifdef _GLIBCPP_HAVE_MODFL
|
|
#define HAVE_LONG_DOUBLE 1
|
|
#endif
|
|
|
|
#ifndef HAVE_LONG_DOUBLE
|
|
#define HAVE_LONG_DOUBLE 0
|
|
#endif
|
|
|
|
// So we can save this object
|
|
#include <tqstring.h>
|
|
#include <tqdatastream.h>
|
|
#include <kmymoney/export.h>
|
|
#include <kmymoney/mymoneyexception.h>
|
|
|
|
#ifndef __STDC_LIMIT_MACROS
|
|
#define __STDC_LIMIT_MACROS // force definition of min and max values
|
|
#endif
|
|
#include <inttypes.h>
|
|
|
|
typedef int64_t signed64;
|
|
typedef uint64_t unsigned64;
|
|
|
|
class MyMoneyAccount;
|
|
class MyMoneySecurity;
|
|
|
|
/**
|
|
* This class represents a value within the MyMoney Engine
|
|
*
|
|
* @author Michael Edwardes
|
|
*/
|
|
class KMYMONEY_EXPORT MyMoneyMoney
|
|
{
|
|
public:
|
|
enum fileVersionE {
|
|
FILE_4_BYTE_VALUE = 0,
|
|
FILE_8_BYTE_VALUE
|
|
};
|
|
|
|
enum signPosition {
|
|
// keep those in sync with the ones defined in tdelocale.h
|
|
ParensAround = 0,
|
|
BeforeQuantityMoney = 1,
|
|
AfterQuantityMoney = 2,
|
|
BeforeMoney = 3,
|
|
AfterMoney = 4
|
|
};
|
|
|
|
enum roundingMethod {
|
|
RndNever = 0,
|
|
RndFloor,
|
|
RndCeil,
|
|
RndTrunc,
|
|
RndPromote,
|
|
RndHalfDown,
|
|
RndHalfUp,
|
|
RndRound
|
|
};
|
|
|
|
// construction
|
|
MyMoneyMoney();
|
|
MyMoneyMoney( const int iAmount, const signed64 denom = 100 );
|
|
MyMoneyMoney( const TQString& pszAmount );
|
|
MyMoneyMoney( const signed64 Amount, const signed64 denom = 100 );
|
|
MyMoneyMoney( const double dAmount, const signed64 denom = 100 );
|
|
#if HAVE_LONG_DOUBLE
|
|
MyMoneyMoney( const long double dAmount, const signed64 denom = 100 );
|
|
#endif
|
|
|
|
// copy constructor
|
|
MyMoneyMoney( const MyMoneyMoney& AmountInPence );
|
|
|
|
// signed64 value(const int prec = 2) const;
|
|
const MyMoneyMoney abs(void) const { return m_num < 0 ? -(*this) : *this; };
|
|
|
|
/**
|
|
* This method returns a formatted string according to the settings
|
|
* of _thousandSeparator, _decimalSeparator, _negativeMonetarySignPosition,
|
|
* _positiveMonetaryPosition, _negativePrefixCurrencySymbol and
|
|
* _positivePrefixCurrencySymbol. Those values can be modified using
|
|
* the appropriate set-methods.
|
|
*
|
|
* @param currency The currency symbol
|
|
* @param prec The number of fractional digits
|
|
* @param showThousandSeparator should the thousandSeparator symbol be inserted
|
|
* (@a true) or not (@a false) (default true)
|
|
*/
|
|
TQString formatMoney(const TQString& currency, const int prec, bool showThousandSeparator = true) const;
|
|
|
|
/**
|
|
* This is a convenience method. It behaves exactly as the above one, but takes the information
|
|
* about currency symbol and precision out of the MyMoneySecurity and MyMoneyAccount objects
|
|
* @a acc and @a sec.
|
|
*/
|
|
TQString formatMoney(const MyMoneyAccount& acc, const MyMoneySecurity& sec, bool showThousandSeparator = true) const;
|
|
|
|
/**
|
|
* This is a convenience method. It behaves exactly as the above one, but takes the information
|
|
* about currency symbol and precision out of the MyMoneySecurity object @a sec.
|
|
*/
|
|
TQString formatMoney(const MyMoneySecurity& sec, bool showThousandSeparator = true) const;
|
|
|
|
/**
|
|
* This is a convenience method. It behaves exactly as the above one, but takes the information
|
|
* about precision out of the denomination @a denom. No currency symbol is shown. If you want
|
|
* to see a currency symbol, please use formatMoney(const MyMoneyAccount& acc, const MyMoneySecurity& sec, bool showThousandSeparator)
|
|
* instead.
|
|
*
|
|
* @note denom is often set to account.fraction(security).
|
|
*/
|
|
TQString formatMoney(int denom, bool showThousandSeparator = true) const;
|
|
|
|
/**
|
|
* This method is used to convert the smallest fraction information into
|
|
* the corresponding number of digits used for precision.
|
|
*
|
|
* @param fract smallest fractional part (e.g. 100 for cents)
|
|
* @return number of precision digits (e.g. 2 for cents)
|
|
*/
|
|
static int denomToPrec(signed64 fract);
|
|
|
|
const TQString toString(void) const;
|
|
const MyMoneyMoney convert(const signed64 denom = 100, const roundingMethod how = RndRound) const;
|
|
static signed64 precToDenom(int prec);
|
|
double toDouble(void) const;
|
|
|
|
static void setThousandSeparator(const unsigned char);
|
|
static void setDecimalSeparator(const unsigned char);
|
|
static void setNegativeMonetarySignPosition(const signPosition pos);
|
|
static void setPositiveMonetarySignPosition(const signPosition pos);
|
|
static void setNegativePrefixCurrencySymbol(const bool flags);
|
|
static void setPositivePrefixCurrencySymbol(const bool flags);
|
|
|
|
static unsigned char thousandSeparator(void);
|
|
static unsigned char decimalSeparator(void);
|
|
static signPosition negativeMonetarySignPosition(void);
|
|
static signPosition positiveMonetarySignPosition(void);
|
|
static void setFileVersion(const fileVersionE version);
|
|
|
|
// assignment
|
|
const MyMoneyMoney& operator=( const MyMoneyMoney& Amount );
|
|
const MyMoneyMoney& operator=( const TQString& pszAmount );
|
|
|
|
// comparison
|
|
bool operator==( const MyMoneyMoney& Amount ) const;
|
|
bool operator!=( const MyMoneyMoney& Amount ) const;
|
|
bool operator<( const MyMoneyMoney& Amount ) const;
|
|
bool operator>( const MyMoneyMoney& Amount ) const;
|
|
bool operator<=( const MyMoneyMoney& Amount ) const;
|
|
bool operator>=( const MyMoneyMoney& Amount ) const;
|
|
|
|
bool operator==( const TQString& pszAmount ) const;
|
|
bool operator!=( const TQString& pszAmount ) const;
|
|
bool operator<( const TQString& pszAmount ) const;
|
|
bool operator>( const TQString& pszAmount ) const;
|
|
bool operator<=( const TQString& pszAmount ) const;
|
|
bool operator>=( const TQString& pszAmount ) const;
|
|
|
|
// calculation
|
|
MyMoneyMoney operator+( const MyMoneyMoney& Amount ) const;
|
|
|
|
MyMoneyMoney operator-( const MyMoneyMoney& Amount ) const;
|
|
MyMoneyMoney operator-( ) const;
|
|
|
|
MyMoneyMoney operator*( const MyMoneyMoney& factor ) const;
|
|
MyMoneyMoney operator*( int factor ) const;
|
|
MyMoneyMoney operator*( signed64 factor ) const;
|
|
MyMoneyMoney operator/( const MyMoneyMoney& Amount ) const;
|
|
|
|
// unary operators
|
|
MyMoneyMoney& operator+= ( const MyMoneyMoney& Amount );
|
|
MyMoneyMoney& operator-= ( const MyMoneyMoney& Amount );
|
|
MyMoneyMoney& operator/= ( const MyMoneyMoney& Amount );
|
|
|
|
// conversion
|
|
operator int() const;
|
|
|
|
static MyMoneyMoney maxValue;
|
|
static MyMoneyMoney minValue;
|
|
static MyMoneyMoney autoCalc;
|
|
|
|
bool isNegative() const { return (m_num < 0) ? true : false; }
|
|
bool isPositive() const { return (m_num > 0) ? true : false; }
|
|
bool isZero() const { return m_num == 0; }
|
|
bool isAutoCalc(void) const { return (*this == autoCalc); }
|
|
|
|
const MyMoneyMoney reduce(void) const;
|
|
|
|
private:
|
|
signed64 m_num;
|
|
signed64 m_denom;
|
|
|
|
signed64 getLcd(const MyMoneyMoney& b) const;
|
|
|
|
KMYMONEY_EXPORT friend TQDataStream &operator<<(TQDataStream &, const MyMoneyMoney &);
|
|
KMYMONEY_EXPORT friend TQDataStream &operator>>(TQDataStream &, MyMoneyMoney &);
|
|
|
|
static unsigned char _thousandSeparator;
|
|
static unsigned char _decimalSeparator;
|
|
static signPosition _negativeMonetarySignPosition;
|
|
static signPosition _positiveMonetarySignPosition;
|
|
static bool _negativePrefixCurrencySymbol;
|
|
static bool _positivePrefixCurrencySymbol;
|
|
static MyMoneyMoney::fileVersionE _fileVersion;
|
|
|
|
};
|
|
|
|
//=============================================================================
|
|
//
|
|
// Inline functions
|
|
//
|
|
//=============================================================================
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: MyMoneyMoney
|
|
// Purpose: Constructor - constructs object set to 0.
|
|
// Returns: None
|
|
// Throws: Nothing.
|
|
// Arguments: None
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney::MyMoneyMoney()
|
|
{
|
|
m_num = 0;
|
|
m_denom = 1;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: MyMoneyMoney
|
|
// Purpose: Constructor - constructs object from an amount in a signed64 value
|
|
// Returns: None
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - signed 64 object containing amount
|
|
// denom - denominator of the object
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney::MyMoneyMoney(signed64 Amount, const signed64 denom)
|
|
{
|
|
if(!denom)
|
|
throw new MYMONEYEXCEPTION("Denominator 0 not allowed!");
|
|
|
|
m_num = Amount;
|
|
m_denom = denom;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: MyMoneyMoney
|
|
// Purpose: Constructor - constructs object from an amount in a double value
|
|
// Returns: None
|
|
// Throws: Nothing.
|
|
// Arguments: dAmount - double object containing amount
|
|
// denom - denominator of the object
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney::MyMoneyMoney(const double dAmount, const signed64 denom)
|
|
{
|
|
double adj = dAmount < 0 ? -0.5 : 0.5;
|
|
m_denom = denom;
|
|
m_num = (signed64) (dAmount * (double)m_denom + adj);
|
|
}
|
|
|
|
#if HAVE_LONG_DOUBLE
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: MyMoneyMoney
|
|
// Purpose: Constructor - constructs object from an amount in a long double value
|
|
// Returns: None
|
|
// Throws: Nothing.
|
|
// Arguments: dAmount - long double object containing amount
|
|
// denom - denominator of the object
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney::MyMoneyMoney(const long double dAmount, const signed64 denom)
|
|
{
|
|
long double adj = dAmount < 0 ? -0.5 : 0.5;
|
|
m_denom = denom;
|
|
m_num = static_cast<signed64> (dAmount * m_denom + adj);
|
|
}
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: MyMoneyMoney
|
|
// Purpose: Constructor - constructs object from an amount in a integer value
|
|
// Returns: None
|
|
// Throws: Nothing.
|
|
// Arguments: iAmount - integer object containing amount
|
|
// denom - denominator of the object
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney::MyMoneyMoney(const int iAmount, const signed64 denom)
|
|
{
|
|
if(!denom)
|
|
throw new MYMONEYEXCEPTION("Denominator 0 not allowed!");
|
|
|
|
m_num = static_cast<signed64>(iAmount);
|
|
m_denom = denom;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: MyMoneyMoney
|
|
// Purpose: Copy Constructor - constructs object from another MyMoneyMoney object
|
|
// Returns: None
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be copied
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney::MyMoneyMoney(const MyMoneyMoney& Amount)
|
|
{
|
|
m_num = Amount.m_num;
|
|
m_denom = Amount.m_denom;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator=
|
|
// Purpose: Assignment operator - modifies object from input MyMoneyMoney object
|
|
// Returns: Const reference to the object
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be modified from
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline const MyMoneyMoney& MyMoneyMoney::operator=(const MyMoneyMoney& Amount)
|
|
{
|
|
m_num = Amount.m_num;
|
|
m_denom = Amount.m_denom;
|
|
return *this;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator=
|
|
// Purpose: Assignment operator - modifies object from input NULL terminated
|
|
// string
|
|
// Returns: Const reference to the object
|
|
// Throws: Nothing.
|
|
// Arguments: pszAmount - NULL terminated string that contains amount
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline const MyMoneyMoney& MyMoneyMoney::operator=(const TQString& pszAmount)
|
|
{
|
|
*this = MyMoneyMoney( pszAmount );
|
|
return *this;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator==
|
|
// Purpose: Compare equal operator - compares object with input MyMoneyMoney object
|
|
// Returns: true if equal, otherwise false
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be compared with
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator==(const MyMoneyMoney& Amount) const
|
|
{
|
|
if(m_denom == Amount.m_denom)
|
|
return m_num == Amount.m_num;
|
|
|
|
if(m_num == 0 && Amount.m_num == 0)
|
|
return true;
|
|
|
|
return (*this - Amount).m_num == 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator!=
|
|
// Purpose: Compare not equal operator - compares object with input MyMoneyMoney object
|
|
// Returns: true if not equal, otherwise false
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be compared with
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator!=(const MyMoneyMoney& Amount) const
|
|
{
|
|
if(m_num == Amount.m_num && m_denom == Amount.m_denom)
|
|
return false;
|
|
|
|
return (*this - Amount).m_num != 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator<
|
|
// Purpose: Compare less than operator - compares object with input MyMoneyMoney object
|
|
// Returns: true if object less than input amount
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be compared with
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator<(const MyMoneyMoney& Amount) const
|
|
{
|
|
if(m_denom == Amount.m_denom)
|
|
return (m_num < Amount.m_num);
|
|
|
|
signed64 ab, ba;
|
|
|
|
ab = m_num * Amount.m_denom;
|
|
ba = m_denom * Amount.m_num;
|
|
|
|
return ( ab < ba ) ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator>
|
|
// Purpose: Compare greater than operator - compares object with input MyMoneyMoney
|
|
// object
|
|
// Returns: true if object greater than input amount
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be compared with
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator>(const MyMoneyMoney& Amount) const
|
|
{
|
|
if(m_denom == Amount.m_denom)
|
|
return (m_num > Amount.m_num);
|
|
|
|
signed64 ab, ba;
|
|
|
|
ab = m_num * Amount.m_denom;
|
|
ba = m_denom * Amount.m_num;
|
|
|
|
return ( ab > ba ) ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator<=
|
|
// Purpose: Compare less than equal to operator - compares object with input
|
|
// MyMoneyMoney object
|
|
// Returns: true if object less than or equal to input amount
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be compared with
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator<=(const MyMoneyMoney& Amount) const
|
|
{
|
|
if(m_denom == Amount.m_denom)
|
|
return (m_num <= Amount.m_num);
|
|
|
|
signed64 ab, ba;
|
|
|
|
ab = m_num * Amount.m_denom;
|
|
ba = m_denom * Amount.m_num;
|
|
|
|
return ( ab <= ba ) ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator>=
|
|
// Purpose: Compare greater than equal to operator - compares object with input
|
|
// MyMoneyMoney object
|
|
// Returns: true if object greater than or equal to input amount
|
|
// Throws: Nothing.
|
|
// Arguments: Amount - MyMoneyMoney object to be compared with
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator>=(const MyMoneyMoney& Amount) const
|
|
{
|
|
if(m_denom == Amount.m_denom)
|
|
return (m_num >= Amount.m_num);
|
|
|
|
signed64 ab, ba;
|
|
|
|
ab = m_num * Amount.m_denom;
|
|
ba = m_denom * Amount.m_num;
|
|
|
|
return ( ab >= ba ) ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator==
|
|
// Purpose: Compare equal operator - compares object with input amount in a
|
|
// NULL terminated string
|
|
// Returns: true if equal, otherwise false
|
|
// Throws: Nothing.
|
|
// Arguments: pszAmount - NULL terminated string that contains amount
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator==(const TQString& pszAmount) const
|
|
{
|
|
MyMoneyMoney Amount( pszAmount );
|
|
return ( *this == Amount ) ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator!=
|
|
// Purpose: Compare not equal operator - compares object with input amount in
|
|
// a NULL terminated string
|
|
// Returns: true if not equal, otherwise false
|
|
// Throws: Nothing.
|
|
// Arguments: pszAmount - NULL terminated string that contains amount
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline bool MyMoneyMoney::operator!=(const TQString& pszAmount) const
|
|
{
|
|
MyMoneyMoney Amount( pszAmount );
|
|
return ( *this != Amount ) ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator-
|
|
// Purpose: Unary operator - returns the negative value from the object
|
|
// Returns: The current object
|
|
// Throws: Nothing.
|
|
// Arguments: None
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney MyMoneyMoney::operator-() const
|
|
{
|
|
MyMoneyMoney result(*this);
|
|
result.m_num = -result.m_num;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator*
|
|
// Purpose: Multiplication operator - multiplies the object with factor
|
|
// Returns: The current object
|
|
// Throws: Nothing.
|
|
// Arguments: AmountInPence - signed64 object to be multiplied
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney MyMoneyMoney::operator*(signed64 factor) const
|
|
{
|
|
MyMoneyMoney result(*this);
|
|
result.m_num *= factor;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator*
|
|
// Purpose: Multiplication operator - multiplies the object with factor
|
|
// Returns: The current object
|
|
// Throws: Nothing.
|
|
// Arguments: AmountInPence - long object to be multiplied
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney MyMoneyMoney::operator*(int factor) const
|
|
{
|
|
MyMoneyMoney result(*this);
|
|
result.m_num *= factor;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator+=
|
|
// Purpose: Addition operator - adds the input amount to the object together
|
|
// Returns: Reference to the current object
|
|
// Throws: Nothing.
|
|
// Arguments: AmountInPence - MyMoneyMoney object to be added
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney& MyMoneyMoney::operator+=(const MyMoneyMoney& AmountInPence)
|
|
{
|
|
*this = *this + AmountInPence;
|
|
return *this;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Name: operator-=
|
|
// Purpose: Subtraction operator - subtracts the input amount from the object
|
|
// Returns: Reference to the current object
|
|
// Throws: Nothing.
|
|
// Arguments: AmountInPence - MyMoneyMoney object to be subtracted
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
inline MyMoneyMoney& MyMoneyMoney::operator-=(const MyMoneyMoney& AmountInPence)
|
|
{
|
|
*this = *this - AmountInPence;
|
|
return *this;
|
|
}
|
|
|
|
inline MyMoneyMoney& MyMoneyMoney::operator/=(const MyMoneyMoney& AmountInPence)
|
|
{
|
|
*this = *this / AmountInPence;
|
|
return *this;
|
|
}
|
|
|
|
#endif
|
|
|