Imagine that you have the following problem. You have exchange rates for many currencies, but all of the rates are for converting currencies to and from US Dollars. There are no rates for directly converting currency A to currency B when neither A nor B are US Dollars. However, it's likely that you have rates for exchanging A and B to and from US Dollars. In such cases, you can employ an indirect conversion strategy for converting A to B, using US Dollars as the base currency.
This section describes how you can create a class called USDollarBaseExchange to implement such an exchange strategy. The class created here can be used by itself or as an implementation for the RWExchange class.
Source code for the classes and programs described throughout Section 5.7, "Creating Custom Exchange Objects and Groups," are available in buildspace\examples\currency.
The class USDollarBaseExchange inherits from RWExchangeImpl<T>, and implements a currency conversion method that converts a source currency to a US Dollar base, then converts the US Dollar base to a target currency.
Here is the code that declares the class:
class USDollarBaseExchange : public RWExchangeImpl<T>
{
public:
// Constructors ---------------------------------------------------
USDollarBaseExchange();
USDollarBaseExchange( const USDollarBaseExchange<T>& e );
USDollarBaseExchange( const RWCString& source,
const RWCString& target,
double srcToUsdFactor,
double usdToTrgFactor );
// Public Member Functions ----------------------------------------
// Inherited from RWExchangeImpl
// Return a copy of self off the heap. The copy ctor in the
// handle class RWExchange<T> group needs this function
virtual RWExchangeImpl<T>* clone() const;
// Performs the exchange.
virtual RWMoney<T> exchange( const RWMoney<T>& m ) const;
// Returns the name of this exchange class
virtual RWCString name() const { return "USDollarBaseMethod"; }
// Accessors ----------------------------------------------------
double sourceToUsdFactor() const { return sourceToUsdFactor_; }
double usdToTargetFactor() const { return usdToTargetFactor_; }
// From RWExchangeImpl
//RWCString source() const;
//RWCString target() const;
// Mutators -----------------------------------------------------
void setSourceToUsdFactor( double f ) { sourceToUsdFactor_ = f; }
void setUsdToTargetFactor( double f ) { usdToTargetFactor_ = f; }
// From RWExchangeImpl
//void setSource( const RWCString& src );
//void setTarget( const RWCString& trg );
// Assignment Operator
USDollarBaseExchange<T>& operator=
( const USDollarBaseExchange<T>& );
private:
double sourceToUsdFactor_;
double usdToTargetFactor_;
};
|
First, this class declares a default and copy constructor, and a constructor that provides a source currency mnemonic, a target currency mnemonic, a conversion factor for source to US Dollars, and a conversion factor for US Dollars to target.
Next, it adds definitions for the following inherited virtual functions, and for the assignment operator:
clone() -- Returns a copy of self off the heap.
exchange() -- Performs the conversion.
name() -- Returns the name of this conversion method, in this case USDollarBaseMethod.
operator()
After defining the virtual functions, the class defines sourceToUsDFactor() and usdToTargetFactor(), which return the conversion factors required for this method of conversion. Similarly, it defines functions setSourceToUsDFactor() and setUsdToTarget, which allow the conversion factors to be set.
Class USDollarBaseGroup inherits from RWExchangeGroupImpl<T>, and implements a currency exchange group that produces USDollarBaseExchange objects, which convert a source currency to a US Dollar base, then convert the US Dollar base to a target currency. Here is the code that declares the class:
template< class T >
class USDollarBaseGroup : public RWExchangeGroupImpl<T>
{
public:
USDollarBaseGroup() {;}
// Inherited from RWExchangeGroup
virtual RWExchange<T> getExchange( const RWCString& srcMnemonic,
const RWCString& targetMnemonic,
const RWExchangeRateTable& rates ) const;
virtual RWCString name() const { return "USDollarBaseGroup"; }
virtual RWExchangeGroupImpl<T>* clone() const
{ return (RWExchangeGroupImpl<T>*)new
USDollarBaseGroup<T>(*this);}
};
|
First, this class declares the default constructor. Then it adds definitions for the following inherited virtual functions:
getExchange() -- Creates and returns the currency exchange object.
name() -- Returns the name associated with the group, in this case USDollarBaseGroup.
clone() -- Returns a copy of self allocated off the heap.
The groupexam example demonstrates how to add the classes described in Section 5.7.1, "Class USDollarBaseExchange," and Section 5.7.2, "Class USDollarBaseGroup," to an exchange factory, and how to perform some currency exchanges. Here is an excerpt from the code that creates and populates a currency exchange factory:
//set up exchange rate table rateTable
.
.
.
// Construct an exchange factory with the exchange rate table.
RWExchangeFactory<Decimal> exchangeFactory( rateTable );
// Exchange groups use a handle/body design. The handle class is
// RWExchangeGroup. Instances of this class contain a pointer to
// an implementation class. The static method
// RWEuroGroup<Decimal>::create() creates an RWExchangeGroup
// object with an RWEuroGroup implementation. Function
// appendExchangeGroup appends a Euro exchange group to the
// factory.
exchangeFactory.appendExchangeGroup(
RWEuroGroup<Decimal>::create(euroFile) );
// Create a USDollarBaseGroup exchange group and append it to the
// exchange factory.
USDollarBaseGroup<Decimal>* grpImpl =
new USDollarBaseGroup<Decimal>;
exchangeFactory.appendExchangeGroup(
RWExchangeGroup<Decimal>(grpImpl) );
// Create a division exchange group and insert into the factory
// in the second position.
exchangeFactory.insertExchangeGroupAt( 1,
RWDivisionGroup<Decimal>::create() );
|
The currency exchange factory contains four exchange groups, in the following order: RWMultiplicationGroup, RWDivisionGroup, RWEuroGroup, and USDollarBaseGroup. When the exchange factory gets a request for an exchange object, it will ask each exchange group, in order, to create the exchange object. For example, the following line of code requests an exchange object for converting currency ARP to AUD:
RWExchange<Decimal> exchanger =
exchangeFactory.getExchange( "ARP", "AUD" );
|
In this example, the exchange object, exchanger, is used to perform the actual currency conversion. The example defines function doConversion(), which takes a source currency and an exchange object, and returns a RWMoney object target, which contains the conversion. The doConversion() function prints the results as well. Here is its code:
RWMoney<Decimal> doConversion( const RWMoney<Decimal>& source,
const RWExchange<Decimal>& exchanger )
{
RWMoney<Decimal> target = round( exchanger.exchange(source),2U );
cout << "\nUsing exchange method: " << exchanger.name() << endl;
cout << source.amount() << " " << source.currency() << " = " <<
target.amount() << " " << target.currency() << endl;
return target;
}
|
Let's see how all of these pieces are brought together. The following code excerpt creates two RWMoney objects, source and target, requests an exchange object from the factory, and, if the exchange object is valid, uses the doConversion() function to perform a conversion:
RWMoney<Decimal> source( Decimal("8976.80"), "ARP" );
RWMoney<Decimal> target;
RWExchange<Decimal> exchanger =
exchangeFactory.getExchange( "ARP", "AUD" );
if ( !exchanger.isValid() )
{
cout << "No exchange object for ARP to AUD" << endl;
}
else
{
target = doConversion( source, exchanger );
}
|
You can see the complete source code for this example in buildspace\examples\currency\groupexam.cpp.
Copyright © Rogue Wave Software, Inc. All Rights Reserved.
The Rogue Wave name and logo, and SourcePro, are registered trademarks of Rogue Wave Software. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.