Delphi design mode: "Headfirst design mode" DELPHI7 Code---state mode [go]

{There is no code to apply state mode}

Engineering documents

Program Project1;

{$APPTYPE CONSOLE}

Uses
Ugumballmachine in ' Ugumballmachine.pas ';

Var
Agumballmachine:tgumballmachine;

Begin
Agumballmachine: = Tgumballmachine.create (5);

Agumballmachine.insertquarter;
Agumballmachine.turncrank;

Writeln;

Agumballmachine.insertquarter;
Agumballmachine.ejectquarter;
Agumballmachine.turncrank;

Writeln;

Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.ejectquarter;

Writeln;

Agumballmachine.insertquarter;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;

Agumballmachine.free;

READLN;
End.

Unit files

Unit ugumballmachine;

Interface

Type
Tgumballmachine = Class (TObject)
Private
Fstate:integer;
Fcount:integer;
Public
Constructor Create (Acount:integer);
Procedure Insertquarter;
Procedure Ejectquarter;
Procedure Turncrank;
Procedure dispense;
End

Implementation

Const
sold_out = 0;
No_quarter = 1;
Has_quarter = 2;
SOLD = 3;

{Tgumballmachine}

Constructor Tgumballmachine.create (Acount:integer);
Begin
Fcount: = acount;
Fstate: = Sold_out;
If Fcount > 0 Then
Fstate: = No_quarter;
End

Procedure Tgumballmachine.dispense;
Begin
If fstate = SOLD Then
Begin
Writeln (' A gumball comes rolling out the slot ');
Fcount: = FCount-1;
If Fcount = 0 Then
Begin
Writeln (' Oops, out of Gumballs ');
Fstate: = Sold_out;
End
Else
Fstate: = No_quarter;
End

If fstate = No_quarter Then
Writeln (' You need-pay first ');

If fstate = Sold_out Then
Writeln (' No gumball dispensed ');

If fstate = Has_quarter Then
Writeln (' No gumball dispensed ');
End

Procedure Tgumballmachine.ejectquarter;
Begin
If fstate = Has_quarter Then
Begin
Writeln (' Quarter returned ');
Fstate: = No_quarter;
End

If fstate = No_quarter Then
Writeln (' You haven ' t inserted a quarter ');

If fstate = SOLD Then
Writeln (' Sorry, you already turned the crank ');

If fstate = Sold_out Then
Writeln (' Can ' t eject, you haven ' t inserted a quarter yet ');
End

Procedure Tgumballmachine.insertquarter;
Begin
If fstate = Has_quarter Then
Writeln (' You can ' t insert another quarter ');

If fstate = No_quarter Then
Begin
Fstate: = Has_quarter;
Writeln (' You inserted a quarter ');
End

If fstate = Sold_out Then
Writeln (' You can ' "t insert a quarter, the machine was sold out ');

If fstate = SOLD Then
Writeln (' Please Wait, we ' re already giving you a gumball ');
End

Procedure Tgumballmachine.turncrank;
Begin
If fstate = SOLD Then
Writeln (' Turning twice doesn ' t get you another Gumball ');

If fstate = No_quarter Then
Writeln (' You turned, but there ' s no quarter ');

If fstate = Sold_out Then
Writeln (' You turned, but there ' s no gumballs ');

If fstate = Has_quarter Then
Begin
Writeln (' You turned ... ');
Fstate: = SOLD;
Dispense;
End
End

End.

{Code that applies state mode}

Engineering documents

Program Project1;

{$APPTYPE CONSOLE}

Uses
Ugumballmachine in ' Ugumballmachine.pas ';

Var
Agumballmachine:tgumballmachine;

Begin
Agumballmachine: = Tgumballmachine.create (5);

Agumballmachine.insertquarter;
Agumballmachine.turncrank;

Writeln;

Agumballmachine.insertquarter;
Agumballmachine.ejectquarter;
Agumballmachine.turncrank;

Writeln;

Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.ejectquarter;

Writeln;

Agumballmachine.insertquarter;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;
Agumballmachine.insertquarter;
Agumballmachine.turncrank;

Agumballmachine.free;

READLN;
End.

Unit files

Unit ugumballmachine;

Interface

Type
Tstate = class; Forward declares that two interdependent classes are created.
Tgumballmachine = Class (TObject)
Private
Fsoldoutstate:tstate;
Fnoquarterstate:tstate;
Fhasquarterstate:tstate;
Fsoldstate:tstate;
Fstate:tstate;
Fcount:integer;
function getsoldoutstate:tstate;
function getnoquarterstate:tstate;
function gethasquarterstate:tstate;
function getsoldstate:tstate;
function Getcount:integer;
Public
Constructor Create (Anumbergumballs:integer);
destructor Destroy; Override
Procedure Insertquarter;
Procedure Ejectquarter;
Procedure Turncrank;
Procedure SetState (astate:tstate);
Procedure Releaseball;
End

Tstate = Class (TObject)
Public
Procedure Insertquarter; Virtual Abstract
Procedure Ejectquarter; Virtual Abstract
Procedure Turncrank; Virtual Abstract
Procedure dispense; Virtual Abstract
End

Tnoquarterstate = Class (Tstate)
Private
Fgumballmachine:tgumballmachine;
Public
Constructor Create (agumballmachine:tgumballmachine);
Procedure Insertquarter; Override
Procedure Ejectquarter; Override
Procedure Turncrank; Override
Procedure dispense; Override
End

Thasquarterstate = Class (Tstate)
Private
Fgumballmachine:tgumballmachine;
Public
Constructor Create (agumballmachine:tgumballmachine);
Procedure Insertquarter; Override
Procedure Ejectquarter; Override
Procedure Turncrank; Override
Procedure dispense; Override
End

Tsoldstate = Class (Tstate)
Private
Fgumballmachine:tgumballmachine;
Public
Constructor Create (agumballmachine:tgumballmachine);
Procedure Insertquarter; Override
Procedure Ejectquarter; Override
Procedure Turncrank; Override
Procedure dispense; Override
End

Tsoldoutstate = Class (Tstate)
Private
Fgumballmachine:tgumballmachine;
Public
Constructor Create (agumballmachine:tgumballmachine);
Procedure Insertquarter; Override
Procedure Ejectquarter; Override
Procedure Turncrank; Override
Procedure dispense; Override
End

Implementation

{Tnoquarterstate}

Constructor Tnoquarterstate.create (agumballmachine:tgumballmachine);
Begin
Fgumballmachine: = Agumballmachine;
End

Procedure Tnoquarterstate.dispense;
Begin
Writeln (' You needed-pay first ');
End

Procedure Tnoquarterstate.ejectquarter;
Begin
Writeln (' You haven ' t inserted a quarter ');
End

Procedure Tnoquarterstate.insertquarter;
Begin
Writeln (' You inserted a quarter ');
Fgumballmachine.setstate (fgumballmachine.gethasquarterstate);
End

Procedure Tnoquarterstate.turncrank;
Begin
Writeln (' You turned, but there ' s no quarter ');
End

{Thasquarterstate}

Constructor Thasquarterstate.create (agumballmachine:tgumballmachine);
Begin
Fgumballmachine: = Agumballmachine;
End

Procedure Thasquarterstate.dispense;
Begin
Writeln (' No gumball dispensed ');
End

Procedure Thasquarterstate.ejectquarter;
Begin
Writeln (' Quarter returned ');
Fgumballmachine.setstate (fgumballmachine.getnoquarterstate);
End

Procedure Thasquarterstate.insertquarter;
Begin
Writeln (' You can ' t insert another quarter ');
End

Procedure Thasquarterstate.turncrank;
Begin
Writeln (' You turned ... ');
Fgumballmachine.setstate (fgumballmachine.getsoldstate);
End

{Tsoldstate}

Constructor Tsoldstate.create (agumballmachine:tgumballmachine);
Begin
Fgumballmachine: = Agumballmachine;
End

Procedure Tsoldstate.dispense;
Begin
Fgumballmachine.releaseball;
If Fgumballmachine.getcount > 0 Then
Fgumballmachine.setstate (Fgumballmachine.getnoquarterstate)
Else
Begin
Writeln (' Oop, out of Gumballs ');
Fgumballmachine.setstate (fgumballmachine.getsoldoutstate);
End
End

Procedure Tsoldstate.ejectquarter;
Begin
Writeln (' Sorry, you already turned the crank ');
End

Procedure Tsoldstate.insertquarter;
Begin
Writeln (' Please Wait, we ' re already giving you a gumball ');
End

Procedure Tsoldstate.turncrank;
Begin
Writeln (' Turning twice doesn ' t get you another Gumball ');
End

{Tsoldoutstate}

Constructor Tsoldoutstate.create (agumballmachine:tgumballmachine);
Begin
Fgumballmachine: = Agumballmachine;
End

Procedure Tsoldoutstate.dispense;
Begin
Writeln (' No gumball dispensed ');
End

Procedure Tsoldoutstate.ejectquarter;
Begin
Writeln (' Can ' t eject, you haven ' t inserted a quarter yet ');
End

Procedure Tsoldoutstate.insertquarter;
Begin
Writeln (' You can ' "t insert a quarter, the machine was Sold out ');
End

Procedure Tsoldoutstate.turncrank;
Begin
Writeln (' turned, but there is no gumballs ');
End

{Tgumballmachine}

Constructor Tgumballmachine.create (Anumbergumballs:integer);
Begin
Fsoldoutstate: = Tsoldoutstate.create (self); var self:tgumballmachine;
Fnoquarterstate: = Tnoquarterstate.create (self);
Fhasquarterstate: = Thasquarterstate.create (self);
Fsoldstate: = Tsoldstate.create (self);
Fcount: = Anumbergumballs;
Fstate: = fsoldoutstate;
If anumbergumballs > 0 Then
Fstate: = fnoquarterstate;
End

destructor Tgumballmachine.destroy;
Begin
Fsoldoutstate.free;
Fnoquarterstate.free;
Fhasquarterstate.free;
Fsoldstate.free;
inherited;
End

Procedure Tgumballmachine.ejectquarter;
Begin
Fstate.ejectquarter;
End

function TGumballMachine.GetCount:Integer;
Begin
Result: = Fcount;
End

function TGumballMachine.GetHasQuarterState:TState;
Begin
Result: = fhasquarterstate;
End

function TGumballMachine.GetNoQuarterState:TState;
Begin
Result: = fnoquarterstate;
End

function TGumballMachine.GetSoldOutState:TState;
Begin
Result: = fsoldoutstate;
End

function TGumballMachine.GetSoldState:TState;
Begin
Result: = fsoldstate;
End

Procedure Tgumballmachine.insertquarter;
Begin
Fstate.insertquarter;
End

Procedure Tgumballmachine.releaseball;
Begin
Writeln (' A gumball comes rolling out the slot ... ');
If Fcount <> 0 Then
Fcount: = FCount-1;
End

Procedure Tgumballmachine.setstate (astate:tstate);
Begin
Fstate: = astate;
End

Procedure Tgumballmachine.turncrank;
Begin
Fstate.turncrank;
Fstate.dispense;
End

End.

Run results

Delphi design mode: "Headfirst design mode" DELPHI7 Code---state mode [go]