| // Trans. hpp: This header file contains the definition of the // classes that make up the Transaction portion of this // application. The Transaction classes are interesting in that // they span both sides of the application, i.e., they are used by // both Bank classes and ATM classes. In fact, the transactions // used by the Bank classes do not need to look anything like the // transactions used by the ATM classes. In this implementation, I // have chosen to make them one in the same. The different public // interfaces are supported via #ifdef's using ATM_SIDE and // BANK_SIDE macros to differentiate them. #ifndef _TRANS_ #define _TRANS_ #include <stdio.h> #include <iostream.h> #include <string.h> #include <math.h> #include <time.h> #include ''consts.hpp'' // Forward references class Account; class AccountList; class ATM; // A TimeStamp object encapsulates the data and time of a // transaction. Its current implementation is that of a string // produced via the time and ctime library routines. The reader // should feel free to come up with something more elaborate. class TimeStamp{ char date_time[small_string*2]; public: TimeStamp(); void print(FILE*); }; // All transactions have a TimeStamp, one account name, its PIN // number, and an amount. (Note: While Balance transactions do not // need an amount, they use it to carry back the balance value.) // Recall that protected accessor methods are perfectly // appropriate. The packetize method is used to turn the object // into a string suitable for shipping across the network. It // requires every transaction (derived classes included) to know // the format of this string, but the alternative is to have the // Transaction class grant friendship to the network or at least // provide a collection of accessor methods. The latter tends to be // problematic in that all classes gain access to the abstract // implementation of the Transaction class. This format knowledge // does not imply that a network needs to ship the format as is. It // implies only that they must use it to produce the final packets // they will ship. class Transaction{ TimeStamp timeStamp; char source_account[small_string]; char pin[small_string]; double amount; protected: Transaction(char* account, char* p, double a); char* get_source_account(); double get_amount(); void set_amount(double new_amount); public: virtual void print(FILE*); virtual char* type() = 0; //Only ATM classes use the preprocess, postprocess, and update // methods. The Transaction class for the Bank side of the // application never compiles them into the object code. #ifdef ATM_SIDE virtual int preprocess(ATM*); virtual void postprocess(ATM*); virtual void update(char* info, int count); virtual void packetize(char* buf); #endif // The process and verify_account methods are used only by the // classes on the Bank's side of the application. The Transaction // class for the ATM side of the application never compiles them // into the object code. #ifdef BANK_SIDE virtual int process(AccountList* accounts) = 0; int verify_account(Account*); virtual void packetize(int status, char* buf); #endif }; // The following four classes are the derived classes of the // abstract Transaction class : Deposit, Withdraw, Balance, and // Transfer. class Deposit : public Transaction { public: Deposit(char* account, char* p, double a); void print(FILE*); char* type(); #ifdef ATM_SIDE int preprocess(ATM*); #endif #ifdef BANK_SIDE int process(AccountList* accounts); #endif }; class Withdraw : public Transaction { public: Withdraw(char* account, char* p, double a); char* type(); #ifdef ATM_SIDE int preprocess(ATM*); void postprocess(ATM*); #endif #ifdef BANK_SIDE int process(AccountList* accounts); #endif void print(FILE*); }; class Balance : public Transaction { double balance; public: Balance(char* account, char* p); void print(FILE*); char* type(); #ifdef ATM_SIDE void update(char* info, int count); #endif #ifdef BANK_SIDE int process(AccountList* accounts); #endif }; // The Transfer class adds the additional data member of // target_account since the money needs to be transferred // someplace. class Transfer : public Transaction { char target_account[small_string]; public: Transfer(char* s_account, char* p, char* t_account, double a); void print(FILE*); char* type(); #ifdef ATM_SIDE void packetize(char* buf); #endif #ifdef BANK_SIDE int process(AccountList* accounts); #endif }; class TransactionList{ Transaction** TransList; int transnum; unsigned size; public: TransactionList(unsigned sz); ~TransactionList(); int add_trans(Transaction*); void print(FILE*); void cleanup(); }; #endif |