ProjectReport - Maurya,Shailesh

PROJECT REPORT

CS-586 Software Systems Architecture

Shailesh Maurya

A20354782

[email protected]

Contents:

1. Introduction

2. MDA-EFSM model for the ACCOUNT components

3. Class diagrams of the MDA of the Account components

4. Purpose and main attributes of class

5. Dynamics

6. Source code and patterns

1. Introduction Goal: The goal of this project is to design two different ACCOUNT components using a Model-Driven

Architecture (MDA) and then implement these ACCOUNT components based on this design.

Description of the Project: There are two ACCOUNT components: ACCOUNT-1 and ACCOUNT-2:

ACCOUNT-1 component supports the following operations:

open (string p, string y, float a) // open an account where p is a pin, y is a user’s identification #, and a is

a balance

pin (string x) // provides pin #

deposit (float d) // deposit amount d

withdraw (float w) // withdraw amount w

balance () // display the current balance

login (string y) // login where y is a client’s identification #

logout () // logout from the account

lock (string x) // locks an account where x is a pin

unlock (string x) // unlocks an account where x is a pin

ACCOUNT-2 component supports the following operations:

OPEN (int p, int y, int a) // open an account where p is a pin, y is a user’s identification #, and a

is a balance

PIN (int x) // provides pin #

DEPOSIT (int d) // deposit amount d

WITHDRAW (int w) // withdraw amount w

BALANCE () // display the current balance

LOGIN (int y) // login where y is a client’s identification #

LOGOUT () // logout from the account

suspend () // suspends an account

activate () // activates a suspended account

close () // an account is closed

Both ACCOUNT components are state-based components and support three types of transactions:

withdrawal, deposit, and balance inquiry. Before any transaction can be performed, operation open (p,

y, a) (or OPEN (p, y, a)) must be issued, where y is a client’s identification #, p is a pin used to get

permission to perform transactions and a is an initial balance in the account. It is assumed that open

()/OPEN () operation is issued only once for a given account. Before any transaction can be performed,

operation login(y) must be issued (where y is a client’s identification #) followed by pin(x) (or PIN(x))

operation. The pin(x) (or PIN(x)) operation must contain the valid pin # that must be the same as the pin

# provided in open (p, y, a) (or OPEN (p, y, a)) operation. There is a limit on the number of attempts with

an invalid pin. The account can be overdrawn (below minimum balance), but a penalty may apply. If the

balance is below the minimum balance, then the withdrawal transaction cannot be performed. The

account may become locked by lock operation or suspended by suspend operation. If the account is

locked, withdrawal, deposit, logout and balance transactions cannot be performed. A locked account

becomes unlocked by unlock operation. A suspended account can be activated by activate operation. In

addition, a suspended account can be closed by close operation. The detailed behavior of both

ACCOUNT components is specified using EFSM. Aspects that vary between two ACCOUNT components:

maximum number of times incorrect pin can be entered, minimum balance, display menu(s), messages,

e.g., error messages, etc., penalties, operation names and signatures, data types, etc.

2. MDA-EFSM model for the ACCOUNT components

2.1 General MDA Architecture

This project implements two ATMs implemented using Model Driven Architecture. The ATMs differ in

their user interface specifications, but are similar in behavior. The main goal is to separate the Platform

specific portion of the system from the Platform independent portion. The general outline of the

implementation is to use Model-Driven-Architecture as the overall design, and use an Extended-Finite-

State-Machine (EFSM) to capture the states in which the model can be in at any point of time.

The project uses following OO design patterns:

• State pattern

• Abstract Factory pattern

• Strategy pattern

The project implements the Output Processor using Strategy pattern, and uses Abstract Factory Pattern

to select and initialize a list of output actions for each ATM.

2.2 List of events for the MDA-EFSM

e1: Open()

e2: Login()

e3: IncorrectLogin()

e4: IncorectPin(int max)

e5: CorrectPinBelowMin()

e6: CorrectPinAboveMin()

e7: Deposit()

e8: BelowMinBalance()

e9: AboveMinBalance()

e10:Logout()

e11: Balance()

e12: Withdraw()

e13: WithdrawBelowMinBalance()

e14: NoFunds()

e15: Lock()

e16: IncorrectLock()

e17: Unlock()

e18: IncorrectUnlock()

e19: Suspend()

e20: Activate()

e21: Close()

2.3 List of actions for the MDA-EFSM with their descriptions

A1: StoreData() // stores pin from temporary data store to pin in data store

A2: IncorrectIdMsg() // displays incorrect ID message

A3: IncorrectPinMsg() // displays incorrect pin message

A4: TooManyAttemptsMsg() // display too many attempts message

A5: DisplayMenu() // display a menu with a list of transactions

A6: MakeDeposit() // makes deposit (increases balance by a value stored in temp. data

store)

A7: DisplayBalance() // displays the current value of the balance

A8: PromptForPin() // prompts to enter pin

A9: MakeWithdraw() // makes withdraw (decreases balance by a value stored in temp. data

store)

A10: Penalty() // applies penalty (decreases balance by the amount of penalty)

A11: IncorrectLock Msg() // displays incorrect lock msg

A12: IncorrectUnlock Msg() // displays incorrect unlock msg

A13: NoFundsMsg() // Displays no sufficient funds msg

2.4 State diagram for the MDA-EFSM

check pin ready

overdrawn

idleS1

Locked

IncorrectPin( max )[ attempts<max ] / IncorrectPinMsg; attempts++

CorrectPinAboveMin / DisplayMenu

CorrectPinBelowMin / DisplayMenu

Open / StoreData

IncorrectPin( max )[ attempts==max ] / IncorrectPinMsg; TooManyAttemptsMsg

Login / attempts=0; PromptForPin AboveMinBalance

WithdrawBelowMinBalance / Penalty

BelowMinBalance

Suspended

Close

Activate

Balance / DisplayBalance

Deposit / MakeDeposit


Logout

Withdraw / MakeWithdraw

Lock

Suspend


Logout

Deposit / MakeDeposit

Withdraw / NoFundsMsg

IncorrectUnlock / IncorrectUnlockMsg

IncorrectLock / IncorrectLockMsg

Logout

IncorrectLogin / IncorrectIdMsg

NoFunds / NoFundsMsg

Unlock

Lock

2.5 Pseudo-code of all operations of Input Processors of ACCOUNT-1 and ACCOUNT-2

Operations of the Input Processor (ACCOUNT-1):

open (string p, string y, float a) {

// store p, y and a in temp data store

ds->temp_p=p;

ds->temp_y=y;

ds->temp_a=a;

m->Open();

}

pin (string x) {

if (x==ds->pin) {

if (d->balance > 500)

m->CorrectPinAboveMin ();

else m->CorrectPinBelowMin();

}

else m->IncorrectPin(3)

}

deposit (float d) {

ds->temp_d=d;

m->Deposit();

if (ds->balance>500)

m->AboveMinBalance();

else m->BelowMinBalance();

}

withdraw (float w) {

ds->temp_w=w;

m->withdraw();

if ((ds->balance>500)

m->AboveMinBalance();

else m->WithdrawBelowMinBalance();

}

balance() {m->Balance();}

login (string y) {

if (y==ds->uid)

m->Login();

else m->IncorrectLogin();

}

logout() {m->Logout();}

lock (string x) {

if (ds->pin==x) m->Lock();

else m->IncorrectLock();

}

unlock (string x) {

if (x==ds->pin) {

m->Unlock();

if (ds->balance > 500)

m->AboveMinBalance ();

else m->BelowMinBalance();

}

else m->IncorrectUnlock();

}

Note:

m: is a pointer to the MDA-EFSM object

ds: is a pointer to the Data Store object which contains the following data items:

• balance: contains the current balance

• pin: contains the correct pin #

• uid: contains the correct user ID

• temp_p, temp_y, temp_a, temp_d, temp_w are used to store values of parameters

Operations of the Input Processor (ACCOUNT-2):

OPEN (int p, int y, int a) {

// store p, y and a in temp data store

ds->temp_p=p;

ds->temp_y=y;

ds->temp_a=a;

m->Open();

}

PIN (int x) {

if (x==ds->pin)

m->CorrectPinAboveMin ();

else m->IncorrectPin(3)

}

DEPOSIT (int d) {

ds->temp_d=d;

m->Deposit();

}

WITHDRAW (int w) {

ds->temp_w=w;

if (ds->balance>0)

m->Withdraw();

else m->NoFunds();

}

BALANCE() {m->Balance();}

LOGIN (int y) {

if (y==ds->uid)

m->Login();

else m->IncorrectLogin();

}

LOGOUT() {m->Logout();}

suspend () {m->Suspend();}

activate () {m->Activate();}

close () {m->Close();}

Note:

m: is a pointer to the MDA-EFSM object

ds: is a pointer to the Data Store object which contains the following data items:

• balance: contains the current balance

• pin: contains the correct pin #

• uid: contains the correct user ID

• temp_p, temp_y, temp_a, temp_d, temp_w are used to store values of parameters

3. Class diagrams of the MDA of the Account components Following are the six cumulative class diagrams:

a. High level class diagram

b. This class diagram models state pattern. It represents the associations of – MDA_EFSM and State,

DataStore, ATM1 and ATM2.

c. This class diagram models the abstract and strategy pattern. It represents the association of – Abstract

and ConcreteFactory classes, Strategy classes (StoreData, IncorrectIdMsg, IncorrectPinMsg and

TooManyAttemptsMsg) and Output.

d. This class diagram models the abstract and strategy pattern. It represents the association of –

Abstract and ConcreteFactory classes, Strategy classes (DisplayMenu, MakeDeposit, DisplayBalance and

PromptForPin) and Output.

e. This class diagram models the abstract and strategy pattern. It represents the association of –

Abstract and ConcreteFactory classes, Strategy classes (MakeWithdraw, Penalty and NoFunfsMsg) and

Output.

f. This class diagram models the abstract and strategy pattern. It represents the association of – Abstract

and ConcreteFactory classes, Strategy classes (IncorrectLockMsg and IncorrectUnlockMsg) and Output.

4. Purpose and main attributes of class a. MDA_EFSM class

This class is responsible for change of states. It has various functions that will result in change of state.

These states then perform actions. It captures platform independent behavior and manages state

machine for State pattern.

Attributes:

State s // pointer to current state

public int attempts;

AbstractFactory af =null; //initialize abstract fact

Output output = null; //initialize output

b. State class

This is an interface class which implements different state classes responsible for performing actions.

These state classes are:

b1. StartState class – contains Open() action.

b2. IdleState class – contains Login() and IncorrectLogin() actions.

b3. CheckPinState class – contains IncorrectPin(), CorrectPinAboveMin(), CorrectPinBelowMin()

and Logout() actions.

b4. ReadyState class – contains IncorrectLock(), Deposit(), Balance(), Withdraw(), NoFunds(),

Suspend() and Logout() actions.

b5. OverdrawnState class – contains Deposit(), Balance(), Withdraw(), Lock() and Logout()

actions.

b6. LockedState class – contains Unlock() and IncorrectUnlock() actions.

b7. S1State class – contains AboveMinBalance(), BelowMinBalance() and

WithdrawBelowMinBalance() actions.

b8. SuspendedState class – contains Balance(), Close() and Activate() actions.

c. DataStore class

It is an abstract class for ATM1_DataStore and ATM2_DataStore classes. They contain all the functions

responsible for storing as well as retrieving temporary and permanent values from the data store.

Attributes:

/* Temporary Storage Variables */

float tmpBalance

String tmpPin

String tmpID

float tmpDeposit

float tmpWithdraw

/* Permanent Storage Variables */

float balance

String pin

String id

float deposit

float withdraw

d. ATM1 class

This class is instantiated when user selects ATM1 from the menu listed by Driver. It consists of all the

processing done by ACCOUNT-1 component.

Attributes:

MDAEFSM *mdaefsm //pointer to MDA_EFSM

DataStore *ds //pointer to data store

e. ATM2 class

This class is instantiated when user selects ATM2 from the menu listed by Driver. It consists of all the

processing done by ACCOUNT-2 component.

Attributes:

MDAEFSM *mdaefsm //pointer to MDA_EFSM


f. AbstractFactory class

This is an abstract class for ATM1_ConcreteFactory and ATM2_ConcreteFactory classes. They are

responsible for creating objects of the data stores and actions associated with ATM1 and ATM2.

g. Output class

This class is responsible for handling all the actions.

Attributes:

AbstractFactory *af //pointer to abstract factory


5. Dynamics

5.1 Senario-1

How the deposit is made in the ACCOUNT-1 component, i.e., the following sequence of operations is

issued: open(abc,xyz,100.5), login(xyz), pin(abc), deposit(400), balance(), logout() :

5.2 Senario-2

How an incorrect pin is entered three times in the ACCOUNT-2 component, i.e., the following sequence

of operations is issued: OPEN(123,111,1000), LOGIN(111), PIN(112), PIN(222), PIN(333) :

6. Source code and patterns a. Driver.java:

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import MDA_EFSM.MDAEFSM;

import Output.Output;

import ATM_Machine.ATM1;

import ATM_Machine.ATM2;

import AbstractFactory.ATM1_ConcreteFactory;

import AbstractFactory.ATM2_ConcreteFactory;

/*

* CLASS : Driver ( This is Main function Program)

*/

public class Driver

{

public static void main( String[] args) throws IOException

{

BufferedReader bufferedReader = new BufferedReader(new

InputStreamReader(System.in));

String input = null;

int choice = 1;

System.out.println("!!Welcome!!" );

System.out.println("Enter '1' for ATM Machine - 1" );

System.out.println("Enter '2' for ATM Machine - 2" );

input = bufferedReader.readLine();

if(input.equalsIgnoreCase("1"))

{

ATM1_ConcreteFactory factory = new ATM1_ConcreteFactory();

Output output = new Output(factory,factory.GetDataStore());

MDAEFSM mdaefsm = new MDAEFSM(factory,output);

ATM1 atm = new ATM1(mdaefsm,factory.GetDataStore());

float balance,deposit,withdraw;

String pin, id;

System.out.println("*************************************");

System.out.println(" ATM Machine-1" );

System.out.println(" MENU of Operations" );

System.out.println(" 1. open(String, String, float)" );

System.out.println(" 2. login(String)" );

System.out.println(" 3. pin(String)" );

System.out.println(" 4. deposit(float)" );

System.out.println(" 5. withdraw(float)" );

System.out.println(" 6. balance()" );

System.out.println(" 7. lock(pin)" );

System.out.println(" 8. unlock(pin)" );

System.out.println(" 9. logout()" );

while (true)

{

System.out.println(" Select Operation: ");

System.out.println("1-open,2-login,3-pin,4-deposit,5-withdraw,6-

balance,7-lock,8-unlock,9-logout");


if(input.isEmpty()) continue;

choice = Integer.parseInt(input);

switch(choice)

{

case 1: //open

System.out.println("\n Operation:- open(String

pin, String id, float balance)");

System.out.println(" Enter value of the parameter

pin:");

pin = bufferedReader.readLine();


id:");

id = bufferedReader.readLine();


balance:");


balance = Float.parseFloat(input);

atm.open(pin, id, balance);

break;

case 2: //login

System.out.println(" Operation:- login(String

y)");

System.out.println(" Enter value of id:");

id = bufferedReader.readLine();

atm.login(id);

break;

case 3: //pin

System.out.println(" Operation:- pin(String x)");

System.out.println(" Enter value of pin:");


atm.pin(pin);

break;

case 4: //deposit

System.out.println(" Operation:- deposit(float

d)");


Deposit:");


deposit = Float.parseFloat(input);

atm.deposit(deposit);

break;

case 5: // withdraw

System.out.println(" Operation:- withdraw(float

w)");


Withdraw:");


withdraw = Float.parseFloat(input);

atm.withdraw(withdraw);

break;

case 6: // balance

System.out.println(" Operation:- balance()");

atm.balance();

break;

case 7: // lock

System.out.println(" Operation:- lock(String

pin)");


pin:");


atm.lock(pin);

break;

case 8: // unlock

System.out.println(" Operation:- unlock(String

pin)");


pin:");


atm.unlock(pin);

break;

case 9: // logout

System.out.println(" Operation:- logout()");

atm.logout();

break;

default:

System.out.println("Invalid Choice, please select

from menu");

break;

}

}

}

else if(input.equalsIgnoreCase("2"))

{

ATM2_ConcreteFactory factory = new ATM2_ConcreteFactory();

Output output = new Output(factory,factory.GetDataStore());

MDAEFSM mdaefsm = new MDAEFSM(factory,output);

ATM2 atm = new ATM2(mdaefsm,factory.GetDataStore());

System.out.println("ATM Machine-2" );

int balance,deposit,withdraw,pin,id;

System.out.println("*************************************");

System.out.println(" ATM Machine-2" );

System.out.println(" MENU of Operations" );

System.out.println(" 1. OPEN(int,int,int)" );

System.out.println(" 2. LOGIN(int)" );

System.out.println(" 3. PIN(int)" );

System.out.println(" 4. DEPOSIT(int)" );

System.out.println(" 5. WITHDRAW(int)" );

System.out.println(" 6. BALANCE()" );

System.out.println(" 7. suspend()" );

System.out.println(" 8. activate()" );

System.out.println(" 9. LOGOUT()" );

System.out.println(" 10. close()" );

while (true) {

System.out.println(" Select Operation: ");

System.out.println("1-OPEN,2-LOGIN,3-PIN,4-DEPOSIT,5-WITHDRAW,6-

BALANCE,7-suspend,8-activate,9-LOGOUT,10-close");


if(input.isEmpty()) continue;

choice = Integer.parseInt(input);

switch(choice)

{

case 1: //OPEN

System.out.println("\n Operation:- OPEN(int pin, int id,

int balance)");


pin:");


pin = Integer.parseInt(input);

System.out.println(" Enter value of the parameter id:");


id = Integer.parseInt(input);


balance:");


balance = Integer.parseInt(input);

atm.OPEN(pin, id, balance);

break;

case 2: //LOGIN

System.out.println(" Operation:- LOGIN(int x)");

System.out.println(" Enter value of LOGIN:");


id = Integer.parseInt(input);

atm.LOGIN(id);

break;

case 3: //PIN

System.out.println(" Operation:- PIN(int x)");

System.out.println(" Enter value of pin:");


pin = Integer.parseInt(input);

atm.PIN(pin);

break;

case 4: //DEPOSIT

System.out.println(" Operation:- DEPOSIT(int d)");


Deposit:");


deposit = Integer.parseInt(input);

atm.DEPOSIT(deposit);

break;

case 5: // WITHDRAW

System.out.println(" Operation:- WITHDRAW(int

w)");


Withdraw:");


withdraw = Integer.parseInt(input);

atm.WITHDRAW(withdraw);

break;

case 6: // BALANCE

System.out.println(" Operation:- BALANCE()");

atm.BALANCE();

break;

case 7: // suspend

System.out.println(" Operation:- suspend()");

atm.suspend();

break;

case 8: // activate

System.out.println(" Operation:- activate()");

atm.activate();

break;

case 9: // LOGOUT

System.out.println(" Operation:- LOGOUT()");

atm.LOGOUT();

break;

case 10: // close

System.out.println(" Operation:- close()");

atm.close();

break;

default:

System.out.println("Invalid Choice, please select

from menu");

break;

}

}

}

}

}

b. AbstractFactory.java :

package AbstractFactory;

import DataStore.*;

import Strategy.*;

/*

* INTERFACE:- Abstract Factory pattern starts here

*/

public interface AbstractFactory

{

public DataStore createDataStore();

public DisplayBalance createDisplayBalance();

public DisplayMenu createDisplayMenu();

public IncorrectIdMsg createIncorrectIdMsg();

public IncorrectLockMsg createIncorrectLockMsg();

public IncorrectPinMsg createIncorrectPinMsg();

public IncorrectUnlockMsg createIncorrectUnlockMsg();

public MakeDeposit createMakeDeposit();

public MakeWithdraw createMakeWithdraw();

public NoFundsMsg createNoFundsMsg();

public Penalty createPenalty();

public PromptForPin createPromptForPin();

public StoreData createStoreData();

public TooManyAttemptsMsg createTooManyAttemptsMsg();

}

b1. ATM2_ConcreteFactory.java :


import DataStore.DataStore;

import DataStore.ATM2_DataStore;

import Strategy.*;

public class ATM2_ConcreteFactory implements AbstractFactory

{

DataStore ds = new ATM2_DataStore();

DisplayBalance displayBalance = new ATM2_DisplayBalance();

DisplayMenu displayMenu = new ATM2_DisplayMenu();

IncorrectIdMsg incorrectIdMsg = new ATM2_IncorrectIdMsg();

IncorrectLockMsg incorrectLockMsg = new ATM2_IncorrectLockMsg();

IncorrectPinMsg incorrectPinMsg = new ATM2_IncorrectPinMsg();

IncorrectUnlockMsg incorrectUnlockMsg = new ATM2_IncorrectUnlockMsg();

MakeDeposit makeDeposit = new ATM2_MakeDeposit();

MakeWithdraw makeWithdraw = new ATM2_MakeWithdraw();

NoFundsMsg noFundsMsg = new ATM2_NoFundsMsg();

Penalty penalty = new ATM2_Penalty();

PromptForPin promptForPin = new ATM2_PromptForPin();

StoreData storeData = new ATM2_StoreData();

TooManyAttemptsMsg tooManyAttemptsMsg = new ATM2_TooManyAttemptsMsg();

public void ConcreteFactory()

{

}

public DataStore createDataStore()

{

return(this.ds);

}

public DataStore GetDataStore()

{

return this.ds;

}

public DisplayBalance createDisplayBalance()

{

return this.displayBalance;

}

public DisplayMenu createDisplayMenu()

{

return this.displayMenu;

}

public IncorrectIdMsg createIncorrectIdMsg()

{

return this.incorrectIdMsg;

}

public IncorrectLockMsg createIncorrectLockMsg()

{

return this.incorrectLockMsg;

}

public IncorrectPinMsg createIncorrectPinMsg()

{

return this.incorrectPinMsg;

}

public IncorrectUnlockMsg createIncorrectUnlockMsg()

{

return this.incorrectUnlockMsg;

}

public MakeDeposit createMakeDeposit()

{

return this.makeDeposit;

}

public MakeWithdraw createMakeWithdraw()

{

return this.makeWithdraw;

}

public NoFundsMsg createNoFundsMsg()

{

return this.noFundsMsg;

}

public Penalty createPenalty()

{

return this.penalty;

}

public PromptForPin createPromptForPin()

{

return this.promptForPin;

}

public StoreData createStoreData()

{

return this.storeData;

}

public TooManyAttemptsMsg createTooManyAttemptsMsg()

{

return this.tooManyAttemptsMsg;

}

}

b2. ATM1_ConcreteFactory.java :




import Strategy.*;

public class ATM1_ConcreteFactory implements AbstractFactory

{

DataStore ds = new ATM1_DataStore();

DisplayBalance displayBalance = new ATM1_DisplayBalance();

DisplayMenu displayMenu = new ATM1_DisplayMenu();

IncorrectIdMsg incorrectIdMsg = new ATM1_IncorrectIdMsg();

IncorrectLockMsg incorrectLockMsg = new ATM1_IncorrectLockMsg();

IncorrectPinMsg incorrectPinMsg = new ATM1_IncorrectPinMsg();

IncorrectUnlockMsg incorrectUnlockMsg = new ATM1_IncorrectUnlockMsg();

MakeDeposit makeDeposit = new ATM1_MakeDeposit();

MakeWithdraw makeWithdraw = new ATM1_MakeWithdraw();

NoFundsMsg noFundsMsg = new ATM1_NoFundsMsg();

Penalty penalty = new ATM1_Penalty();

PromptForPin promptForPin = new ATM1_PromptForPin();

StoreData storeData = new ATM1_StoreData();

TooManyAttemptsMsg tooManyAttemptsMsg = new ATM1_TooManyAttemptsMsg();

public void ConcreteFactory()

{

}

public DataStore createDataStore()

{

return(this.ds);

}

public DataStore GetDataStore()

{

return this.ds;

}

public DisplayBalance createDisplayBalance()

{

return this.displayBalance;

}

public DisplayMenu createDisplayMenu()

{

return this.displayMenu;

}

public IncorrectIdMsg createIncorrectIdMsg()

{

return this.incorrectIdMsg;

}

public IncorrectLockMsg createIncorrectLockMsg()

{

return this.incorrectLockMsg;

}

public IncorrectPinMsg createIncorrectPinMsg()

{

return this.incorrectPinMsg;

}

public IncorrectUnlockMsg createIncorrectUnlockMsg()

{

return this.incorrectUnlockMsg;

}

public MakeDeposit createMakeDeposit()

{

return this.makeDeposit;

}

public MakeWithdraw createMakeWithdraw()

{

return this.makeWithdraw;

}

public NoFundsMsg createNoFundsMsg()

{

return this.noFundsMsg;

}

public Penalty createPenalty()

{

return this.penalty;

}

public PromptForPin createPromptForPin()

{

return this.promptForPin;

}

public StoreData createStoreData()

{

return this.storeData;

}

public TooManyAttemptsMsg createTooManyAttemptsMsg()

{

return this.tooManyAttemptsMsg;

}

}

c. ATM1.java :

package ATM_Machine;




/*

* CLASS : ATM1 class is for fetching parameters from

* UI through Driver.java and invoking corresponding

* event in MDA-EFSM

*/

public class ATM1

{

/* Pointer to MDA-EFSM */

MDAEFSM mdaefsm = null;

/* Pointer to DataStore */

DataStore ds = null;

public ATM1(MDAEFSM mdaefsm,DataStore ds)

{

this.mdaefsm = mdaefsm;

this.ds = ds;

}

public void open(String p, String y, float a)

{

if (a>0) {

((ATM1_DataStore)ds).tmpPin = p;

((ATM1_DataStore)ds).tmpBalance = a;

((ATM1_DataStore)ds).tmpID = y;

mdaefsm.Open();

}

else

{

System.out.println("Invalid input");

}

}

public void pin(String x)

{

if(x.equals(((ATM1_DataStore)ds).tmpPin))

{

if(((ATM1_DataStore)ds).tmpBalance > 500)

mdaefsm.CorrectPinAboveMin();

else

mdaefsm.CorrectPinBelowMin();

}

else

{

mdaefsm.IncorrectPin(3);

}

}

public void deposit(float d)

{

if(d > 0)

{

((ATM1_DataStore)ds).tmpDeposit = d;

mdaefsm.Deposit();

if(((ATM1_DataStore)ds).tmpBalance > 500)

{

mdaefsm.AboveMinBalance();

}

else

{

mdaefsm.BelowMinBalance();

}

}

else

{

System.out.println("Invalid Input");

}

}

public void withdraw(float w)

{

if(w>0)

{

((ATM1_DataStore)ds).tmpWithdraw = w;

mdaefsm.Withdraw();

if(((ATM1_DataStore)ds).tmpBalance > 500 )

{


}

else

{

mdaefsm.WithdrawBelowMinBalance();

}

}

else

{

System.out.println("Invalid Input");

}

}

public void balance()

{

mdaefsm.Balance();

}

public void login(String y){

if(y.equals(((ATM1_DataStore)ds).tmpID))

mdaefsm.Login();

else

mdaefsm.IncorrectLogin();

}

public void lock(String x)

{


mdaefsm.Lock();

else

mdaefsm.IncorrectLock();

}

public void unlock(String x)

{


{

mdaefsm.Unlock();

if(((ATM1_DataStore)ds).balance > 500 )

{


}

else

{

mdaefsm.BelowMinBalance();

}

}

else

mdaefsm.IncorrectUnlock();

}

public void logout()

{

mdaefsm.Logout();

}

}

d. ATM2.java :

package ATM_Machine;




/*

* CLASS : ATM2 Machine Implementation for collecting parameters

* from the UI through Driver.java and invoking right event in MDA-EFSm

*/

public class ATM2

{

/* Pointer to MDA-EFSM */

MDAEFSM mdaefsm = null;

/* Pointer to DataStore */


public ATM2(MDAEFSM mdaefsm,DataStore ds)

{


this.ds = ds;

}

public void OPEN(int p, int y, int a)

{

if (a>0) {

((ATM2_DataStore)ds).tmpPin = p;

((ATM2_DataStore)ds).tmpBalance = a;

((ATM2_DataStore)ds).tmpID = y;

mdaefsm.Open();

}

else

{


}

}

public void PIN(int x)

{

if(x == ((ATM2_DataStore)ds).tmpPin)

{

mdaefsm.CorrectPinAboveMin();

}

else

{

mdaefsm.IncorrectPin(2);

}

}

public void DEPOSIT(int d)

{

if (d>0) {

((ATM2_DataStore)ds).tmpDeposit = d;

mdaefsm.Deposit();

}

else

{


}

}

public void WITHDRAW(int w)

{

if (w>0) {

((ATM2_DataStore)ds).tmpWithdraw = w;

if( ((ATM2_DataStore)ds).tmpBalance > 0)

{

mdaefsm.Withdraw();


}

else

{

mdaefsm.NoFunds();

}

}

else

{


}

}

public void BALANCE()

{

mdaefsm.Balance();

}

public void LOGIN(int y){

if(y == (((ATM2_DataStore)ds).tmpID))

mdaefsm.Login();

else

mdaefsm.IncorrectLogin();

}

public void LOGOUT()

{

mdaefsm.Logout();

}

public void suspend()

{

mdaefsm.Suspend();

}

public void activate()

{

mdaefsm.Activate();

}

public void close()

{

mdaefsm.Close();

}

}

e. DataStore.java :

package DataStore;

public abstract class DataStore{}

e1. ATM2_DataStore.java :

package DataStore;

public class ATM2_DataStore extends DataStore

{


public int tmpBalance;

public int tmpPin;

public int tmpID;

public int tmpDeposit;

public int tmpWithdraw;


public int balance;

public int pin;

public int id;

public int deposit;

public int withdraw;

public int getBalance()

{

return this.balance;

}

public int getPin()

{

return this.pin;

}

public int getId()

{

return this.id;

}

public int setBalance()

{

return this.balance = this.tmpBalance;

}

public int setPin()

{

return this.pin = this.tmpPin;

}

public int setId()

{

return this.id = this.tmpID;

}

public void calBalanceDeposit()

{

this.balance = this.balance + this.deposit;

this.tmpBalance = this.balance;

}

public void calBalanceWithdraw()

{

this.balance = this.balance - this.withdraw;


}

public void setDeposit()

{

this.deposit = this.tmpDeposit;

}

public void setWithdraw()

{

this.withdraw = this.tmpWithdraw;

}

public int getDeposit()

{

return this.deposit;

}

public int getWithdraw()

{

return this.withdraw;

}

}

e2. ATM1_DataStore.java :

package DataStore;

public class ATM1_DataStore extends DataStore

{


public float tmpBalance;

public String tmpPin;

public String tmpID;

public float tmpDeposit;

public float tmpWithdraw;


public float balance;

public String pin;

public String id;

public float deposit;

public float withdraw;

public float getBalance()

{


}

public String getPin()

{

return this.pin;

}

public String getId()

{

return this.id;

}

public float setBalance()

{

return this.balance = this.tmpBalance;

}

public String setPin()

{

return this.pin = this.tmpPin;

}

public String setId()

{

return this.id = this.tmpID;

}

public float setPenalty()

{

this.balance = this.balance - 20;

this.tmpBalance = balance;


}

public void calBalanceDeposit()

{

this.balance = this.balance + this.deposit;


}

public void calBalanceWithdraw()

{

this.balance = this.balance - this.withdraw;


}

public void setDeposit()

{

this.deposit = this.tmpDeposit;

}

public void setWithdraw()

{

this.withdraw = this.tmpWithdraw;

}

public float getDeposit()

{

return this.deposit;

}

public float getWithdraw()

{

return this.withdraw;

} }

f. MDAEFSM.java :

package MDA_EFSM;

import AbstractFactory.AbstractFactory;

import Output.Output;

/*

* CLASS : MDAEFSM ( State Pattern starts here)

*/

public class MDAEFSM {

State checkpinState = new CheckPinState(this);

State idleState = new IdleState(this);

State lockedState = new LockedState(this);

State overdrawnState = new OverdrawnState(this);

State readyState = new ReadyState(this);

State s1State = new S1State(this);

State startState = new StartState(this);

State suspendedState = new SuspendedState(this);

State s = null;

public int attempts;

AbstractFactory af =null;

Output output = null;

public MDAEFSM(AbstractFactory af,Output output) {

s = startState;

attempts = 0;

this.af = af;

this.output = output;

}

public void Open()

{

s.Open();

printCurrentState();

}

public void Login()

{

s.Login();

attempts = 0;


}

public void IncorrectLogin()

{

s.IncorrectLogin();


}

public void IncorrectPin(int max)

{

s.IncorrectPin(max);


}

public void CorrectPinBelowMin()

{

s.CorrectPinBelowMin();


}

public void CorrectPinAboveMin()

{

s.CorrectPinAboveMin();


}

public void Deposit()

{

s.Deposit();


}

public void BelowMinBalance()

{

s.BelowMinBalance();


}

public void AboveMinBalance()

{

s.AboveMinBalance();


}

public void Logout()

{

s.Logout();


}

public void Balance()

{

s.Balance();


}

public void Withdraw()

{

s.Withdraw();


}

public void WithdrawBelowMinBalance()

{

s.WithdrawBelowMinBalance();


}

public void NoFunds()

{

s.NoFunds();


}

public void Lock()

{

s.Lock();


}

public void IncorrectLock()

{

s.IncorrectLock();


}

public void Unlock()

{

s.Unlock();


}

public void IncorrectUnlock()

{

s.IncorrectUnlock();


}

public void Suspend()

{

s.Suspend();


}

public void Activate()

{

s.Activate();


}

public void Close()

{

s.Close();


}

public void setState(State s)

{

this.s = s;

}

public State getMachineState() {

return s;

}

public State getCheckPinState() {

return checkpinState;

}

public State getSuspendedState() {

return suspendedState;

}

public State getIdleState() {

return idleState;

}

public State getStartState() {

return startState;

}

public State getLockedState() {

return lockedState;

}

public State getOverdrawnState() {

return overdrawnState;

}

public State getReadyState() {

return readyState;

}

public State getS1State() {

return s1State;

}

public void printCurrentState(){

System.out.println("--> Current State : "+ s.getClass().getName());

}

}

g. State.java :

package MDA_EFSM;

public interface State

{

public void Open();

public void Login();

public void IncorrectLogin();

public void IncorrectPin(int max);

public void CorrectPinBelowMin();

public void CorrectPinAboveMin();

public void Deposit();

public void BelowMinBalance();

public void AboveMinBalance();

public void Logout();

public void Balance();

public void Withdraw();

public void WithdrawBelowMinBalance();

public void NoFunds();

public void Lock();

public void IncorrectLock();

public void Unlock();

public void IncorrectUnlock();

public void Suspend();

public void Activate();

public void Close();

}

g1. OverdrawnState.java :

package MDA_EFSM;

public class OverdrawnState implements State

{

MDAEFSM mdaefsm =null;

public OverdrawnState(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

}


{

}


{

}


{

}


{

}


{

mdaefsm.output.MakeDeposit();

mdaefsm.setState(mdaefsm.getS1State());

}


{

}


{

}


{

mdaefsm.setState(mdaefsm.getIdleState());

}


{

mdaefsm.output.DisplayBalance();

}


{

mdaefsm.output.NoFundsMsg();

}


{

}


{

}

public void Lock()

{

mdaefsm.setState(mdaefsm.getLockedState());

}


{

}


{

}


{

}


{

}


{

}

public void Close()

{

}

}

g2. CheckPinState.java :

package MDA_EFSM;

public class CheckPinState implements State

{


public CheckPinState(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

}


{

}


{

if( mdaefsm.attempts < max )

{

mdaefsm.attempts++;

mdaefsm.output.IncorrectPinMsg();

}

else if( mdaefsm.attempts == max )

{

mdaefsm.output.IncorrectPinMsg();

mdaefsm.output.TooManyAttemptsMsg();


}

}


{

mdaefsm.output.DisplayMenu();

mdaefsm.setState(mdaefsm.getOverdrawnState());

}


{

mdaefsm.output.DisplayMenu();

mdaefsm.setState(mdaefsm.getReadyState());

}


{

}


{

}


{

}


{


}


{

}


{

}


{

}


{

}

public void Lock()

{

}


{

}


{

}


{

}


{

}


{

}

public void Close()

{

}

}

g3. IdleState.java :

package MDA_EFSM;

public class IdleState implements State

{


public IdleState(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

mdaefsm.attempts = 0;

mdaefsm.output.PromptForPin();

mdaefsm.setState(mdaefsm.getCheckPinState());

}


{

mdaefsm.output.IncorrectIdMsg();

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}

public void Lock()

{

}


{

}


{

}


{

}


{

}


{

}

public void Close()

{

}

}

g4. LockedState.java :

package MDA_EFSM;

public class LockedState implements State

{


public LockedState(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}

public void Lock()

{

}


{

}


{


}


{

mdaefsm.output.IncorrectUnlockMsg();

}


{

}


{

}

public void Close()

{

}

}

g5. ReadyState.java :

package MDA_EFSM;

public class ReadyState implements State

{


public ReadyState(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

}


{

}


{

}


{

}


{

}


{

mdaefsm.output.MakeDeposit();

}


{

}


{

}


{


}


{


}


{

mdaefsm.output.MakeWithdraw();


}


{

}


{

mdaefsm.output.NoFundsMsg();

}

public void Lock()

{

mdaefsm.setState(mdaefsm.getLockedState());

}


{

mdaefsm.output.IncorrectLockMsg();

}


{

}


{

}


{

mdaefsm.setState(mdaefsm.getSuspendedState());

}


{

}

public void Close()

{

}

}

g6. S1State.java :

package MDA_EFSM;

public class S1State implements State

{


public S1State(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

}


{

}


{

}


{

}


{

}


{

}


{


}


{


}


{

}


{

}


{

}


{

mdaefsm.output.Penalty();


}


{

}

public void Lock()

{

}


{

}


{

}


{

}


{

}


{

}

public void Close()

{

}

}

g7. StartState.java :

package MDA_EFSM;

public class StartState implements State

{


public StartState(MDAEFSM mdaefsm)

{


}

public void Open()

{

mdaefsm.output.StoreData();


}

public void Login()

{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}

public void Lock()

{

}


{

}


{

}


{

}


{

}


{

}

public void Close()

{

}

}

g8. SuspendedState.java :

package MDA_EFSM;

public class SuspendedState implements State

{


public SuspendedState(MDAEFSM mdaefsm)

{


}

public void Open()

{

}

public void Login()

{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{

}


{


}


{

}


{

}


{

}

public void Lock()

{

}


{

}


{

}


{

}


{

}


{


}

public void Close()

{

mdaefsm.setState(mdaefsm.getStartState());

}

}

h. Output.java :

package Output;


import AbstractFactory.*;

import Strategy.DisplayBalance;

import Strategy.DisplayMenu;

import Strategy.IncorrectIdMsg;

import Strategy.IncorrectLockMsg;

import Strategy.IncorrectPinMsg;

import Strategy.IncorrectUnlockMsg;

import Strategy.MakeDeposit;

import Strategy.MakeWithdraw;

import Strategy.NoFundsMsg;

import Strategy.Penalty;

import Strategy.PromptForPin;

import Strategy.StoreData;

import Strategy.TooManyAttemptsMsg;

/*

* CLASS : Output

*/

public class Output

{

AbstractFactory af =null;


public Output(AbstractFactory af,DataStore ds)

{

this.af = af;

this.ds = ds;

}

public void IncorrectIdMsg()

{

System.out.println("\n OUTPUT --> Action IncorrectIdMsg");

IncorrectIdMsg incorrectID = af.createIncorrectIdMsg();

incorrectID.IncorrectIdMsg();

}

public void IncorrectPinMsg()

{

System.out.println("\n OUTPUT --> Action IncorrectPinMsg");

IncorrectPinMsg incorrectPin = af.createIncorrectPinMsg();

incorrectPin.IncorrectPinMsg();

}

public void IncorrectLockMsg()

{

System.out.println("\n OUTPUT --> Action IncorrectLockMsg");

IncorrectLockMsg incorrectLock = af.createIncorrectLockMsg();

incorrectLock.IncorrectLockMsg();

}

public void IncorrectUnlockMsg()

{

System.out.println("\n OUTPUT --> Action IncorrectUnlockMsg");

IncorrectUnlockMsg incorrectUnlock = af.createIncorrectUnlockMsg();

incorrectUnlock.IncorrectUnlockMsg();

}

public void TooManyAttemptsMsg()

{

System.out.println("\n OUTPUT --> Action TooManyAttemptsMsg");

TooManyAttemptsMsg tooManyAttempts = af.createTooManyAttemptsMsg();

tooManyAttempts.TooManyAttemptsMsg();

}

public void DisplayMenu()

{

System.out.println("\n OUTPUT --> Action DisplayMenu");

DisplayMenu displayMenu = af.createDisplayMenu();

displayMenu.DisplayMenu();

}

public void StoreData()

{

System.out.println("\n OUTPUT --> Action StoreData");

StoreData storeData = af.createStoreData();

storeData.StoreData(ds);

}

public void NoFundsMsg()

{

System.out.println("\n OUTPUT --> Action NoFundsMsg");

NoFundsMsg noFunds = af.createNoFundsMsg();

noFunds.NoFundsMsg();

}

public void PromptForPin()

{

System.out.println("\n OUTPUT --> Action PromptForPin ");

PromptForPin promptForPin = af.createPromptForPin();

promptForPin.PromptForPin();

}

public void DisplayBalance()

{

System.out.println("\n OUTPUT --> Action DisplayBalance ");

DisplayBalance displayBalance = af.createDisplayBalance();

displayBalance.DisplayBalance(ds);

}

public void MakeDeposit()

{

System.out.println("\n OUTPUT --> Action MakeDeposit ");

MakeDeposit makeDeposit = af.createMakeDeposit();

makeDeposit.MakeDeposit(ds);

}

public void MakeWithdraw()

{

System.out.println("\n OUTPUT --> Action MakeWithdraw ");

MakeWithdraw makeWithdraw = af.createMakeWithdraw();

makeWithdraw.MakeWithdraw(ds);

}

public void Penalty()

{

System.out.println("\n OUTPUT --> Action Penalty ");

Penalty penalty = af.createPenalty();

penalty.Penalty(ds);

}

}

i. DisplayBalance.java :

package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : DisplayBalance (STRAGTEGY PATTERN)

*/

public abstract class DisplayBalance

{

public abstract void DisplayBalance(DataStore ds);

}

i1. ATM1_DisplayBalance.java :

package Strategy;

public class ATM1_DisplayMenu extends DisplayMenu

{


{

System.out.println("ATM Machine 1 Transaction Menu: ");

System.out.println(" Balance " );

System.out.println(" Deposit " );

System.out.println(" Withdraw " );

}

}

i2. ATM2_DisplayBalance.java :

package Strategy;

import DataStore.*;

public class ATM2_DisplayBalance extends DisplayBalance

{

public void DisplayBalance(DataStore dataStore)

{

System.out.println("ATM Machine 2:: Balance is: " +

((ATM2_DataStore)dataStore).getBalance() );

} }

j. DisplayMenu.java :

package Strategy;

/*

* ABSTRACT CLASS : DisplayMenu (Strategy pattern starts here)

*/

public abstract class DisplayMenu

{

public abstract void DisplayMenu();

}

j1. ATM1_DisplayMenu.java :

package Strategy;


{


{





} }

j2. ATM2_DisplayMenu.java :

package Strategy;


{


{





}

}

k. IncorrectIdMsg.java :

package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : IncorrectIdMsg (STRAGTEGY PATTERN)

*/

public abstract class IncorrectIdMsg

{

public abstract void IncorrectIdMsg();

}

k1. ATM1_IncorrectIdMsg.java :

package Strategy;

public class ATM1_IncorrectIdMsg extends IncorrectIdMsg

{


{

System.out.println("ATM Machine 1:: Incorrect Id: ");

}

}

k2. ATM2_IncorrectIdMsg.java : package Strategy;

public class ATM2_IncorrectIdMsg extends IncorrectIdMsg

{


{

System.out.println("ATM Machine 2:: Incorrect Id: ");

}

}

l. IncorrectLockMsg.java :

package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : IncorrectLockMsg (STRAGTEGY PATTERN)

*/

public abstract class IncorrectLockMsg

{

public abstract void IncorrectLockMsg();

}

l1. ATM1_IncorrectLockMsg.java :

package Strategy;

public class ATM1_IncorrectLockMsg extends IncorrectLockMsg

{


{

System.out.println("ATM Machine 1:: Incorrect Lock ");

}

}

l2. ATM2_IncorrectLockMsg.java :

package Strategy;

public class ATM2_IncorrectLockMsg extends IncorrectLockMsg

{


{

System.out.println("ATM Machine 2:: Incorrect Lock ");

}

}

m. IncorrectPinMsg.java :

package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : IncorrectPinMsg (STRAGTEGY PATTERN)

*/

public abstract class IncorrectPinMsg

{

public abstract void IncorrectPinMsg();

}

m1. ATM1_IncorrectPinMsg.java :

package Strategy;

public class ATM1_IncorrectPinMsg extends IncorrectPinMsg

{


{

System.out.println("ATM Machine 1:: Incorrect Pin: ");

}

}

m2. ATM2_IncorrectPinMsg.java :

package Strategy;

public class ATM2_IncorrectPinMsg extends IncorrectPinMsg

{


{

System.out.println("ATM Machine 2:: Incorrect Pin: ");

}

}

n. IncorrectUnlockMsg.java :

package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : IncorrectUnlockMsg (STRAGTEGY PATTERN)

*/

public abstract class IncorrectUnlockMsg

{

public abstract void IncorrectUnlockMsg();

}

n1. ATM1_IncorrectUnlockMsg.java :

package Strategy;

public class ATM1_IncorrectUnlockMsg extends IncorrectUnlockMsg

{


{

System.out.println("ATM Machine 1:: Incorrect Unlock ");

}

}

n2. ATM2_IncorrectUnlockMsg.java : package Strategy;

public class ATM2_IncorrectUnlockMsg extends IncorrectUnlockMsg

{


{

System.out.println("ATM Machine 2:: Incorrect Unlock ");

}

}

o. MakeDeposit.java : package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : MakeDeposit (STRAGTEGY PATTERN)

*/

public abstract class MakeDeposit

{

public abstract void MakeDeposit(DataStore dataStore);

}

o1. ATM1_MakeDeposit.java : package Strategy;

import DataStore.*;

public class ATM1_MakeDeposit extends MakeDeposit

{

public void MakeDeposit(DataStore dataStore)

{

((ATM1_DataStore)dataStore).setDeposit();

((ATM1_DataStore)dataStore).calBalanceDeposit();

System.out.println("ATM Machine 1:: After Deposit, Balance is " +


}

}

o2. ATM2_MakeDeposit.java : package Strategy;

import DataStore.*;

public class ATM2_MakeDeposit extends MakeDeposit

{

public void MakeDeposit(DataStore dataStore)

{

((ATM2_DataStore)dataStore).setDeposit();

((ATM2_DataStore)dataStore).calBalanceDeposit();

System.out.println("ATM Machine 2:: After Deposit, Balance is " +


}

}

p. MakeWithdraw.java : package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : MakeWithdraw (STRAGTEGY PATTERN)

*/

public abstract class MakeWithdraw

{

public abstract void MakeWithdraw(DataStore dataStore);

}

p1. ATM1_MakeWithdraw.java : package Strategy;

import DataStore.*;

public class ATM1_MakeWithdraw extends MakeWithdraw

{

public void MakeWithdraw(DataStore dataStore)

{

((ATM1_DataStore)dataStore).setWithdraw();

((ATM1_DataStore)dataStore).calBalanceWithdraw();

System.out.println("ATM Machine 1:: After Withdraw, Balance is " +


}

}

p2. ATM2_MakeWithdraw.java : package Strategy;

import DataStore.*;

public class ATM2_MakeWithdraw extends MakeWithdraw

{

public void MakeWithdraw(DataStore dataStore)

{

((ATM2_DataStore)dataStore).setWithdraw();

((ATM2_DataStore)dataStore).calBalanceWithdraw();

System.out.println("ATM Machine 2:: After Withdraw, Balance is " +


}

}

q. NoFundsMsg.java : package Strategy;

/*

* ABSTRACT CLASS : NoFundsMsg (STRAGTEGY PATTERN)

*/

public abstract class NoFundsMsg

{

public abstract void NoFundsMsg();

}

q1. ATM1_NoFundsMsg.java : package Strategy;

public class ATM1_NoFundsMsg extends NoFundsMsg

{


{

System.out.println("ATM Machine 1:: No Funds ");

}

}

q2. ATM2_NoFundsMsg.java : package Strategy;

public class ATM2_NoFundsMsg extends NoFundsMsg

{


{

System.out.println("ATM Machine 2:: No Funds ");

}

}

r. Penalty.java : package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : Penalty (STRAGTEGY PATTERN)

*/

public abstract class Penalty

{

public abstract void Penalty(DataStore dataStore);

}

r1. ATM1_Penalty.java : package Strategy;

import DataStore.*;

public class ATM1_Penalty extends Penalty

{

public void Penalty(DataStore dataStore)

{

((ATM1_DataStore)dataStore).setPenalty();

System.out.println("ATM Machine 1:: Minimum required balance is $500. So

Penalty is applied.");

System.out.println("ATM Machine 1:: After a Penalty of 20$, Balance is "

+ ((ATM1_DataStore)dataStore).balance );

}

}

r2. ATM2_Penalty.java : package Strategy;

import DataStore.*;

public class ATM2_Penalty extends Penalty

{

public void Penalty(DataStore dataStore)

{

}

}

s. PromptForPin.java :

package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : PromptForPin (STRAGTEGY PATTERN)

*/

public abstract class PromptForPin

{

public abstract void PromptForPin();

}

s1. ATM1_PromptForPin.java : package Strategy;

public class ATM1_PromptForPin extends PromptForPin

{


{

System.out.println("ATM Machine 1:: Enter the Pin:: " );

}

}

s2. ATM2_PromptForPin.java : package Strategy;

public class ATM2_PromptForPin extends PromptForPin

{


{

System.out.println("ATM Machine 2:: Enter the Pin:: " );

}

}

t. StoreData.java : package Strategy;

import DataStore.*;

/*

* ABSTRACT CLASS : StoreData (STRAGTEGY PATTERN)

*/

public abstract class StoreData

{

public abstract void StoreData(DataStore datastore);

}

t1. ATM1_StoreData.java : package Strategy;

import DataStore.*;

public class ATM1_StoreData extends StoreData

{

public void StoreData(DataStore dataStore)

{

((ATM1_DataStore)dataStore).setPin();

((ATM1_DataStore)dataStore).setBalance();

System.out.println("ATM Machine 1:: After storing the pin and balance,

PIN is " + ((ATM1_DataStore)dataStore).pin + "and Balance is " +

((ATM1_DataStore)dataStore).balance);

}

}

t2. ATM2_StoreData.java : package Strategy;

import DataStore.*;

public class ATM2_StoreData extends StoreData

{

public void StoreData(DataStore dataStore)

{

((ATM2_DataStore)dataStore).setPin();

((ATM2_DataStore)dataStore).setBalance();

System.out.println("ATM Machine 2:: After storing the pin and balance, PIN is

" + ((ATM2_DataStore)dataStore).pin + " and Balance is " +

((ATM2_DataStore)dataStore).balance);

}

}

u. TooManyAttemptsMsg.java : package Strategy;

/*

* ABSTRACT CLASS : TooManyAttemptsMsg (STRAGTEGY PATTERN)

*/

public abstract class TooManyAttemptsMsg

{

public abstract void TooManyAttemptsMsg();

}

u1. ATM1_TooManyAttemptsMsg.java : package Strategy;

public class ATM1_TooManyAttemptsMsg extends TooManyAttemptsMsg

{


{

System.out.println("ATM Machine 1:: Too Many Attempts: ");

}

}

u2. ATM2_TooManyAttemptsMsg.java : package Strategy;

public class ATM2_TooManyAttemptsMsg extends TooManyAttemptsMsg

{


{

System.out.println("ATM Machine 2:: Too Many Attempts: ");

}

}

ProjectReport - Maurya,Shailesh

Documents

Transcript of ProjectReport - Maurya,Shailesh