The Trans.hpp File

// 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