PROBLEM STATEMENT:

Given a five button character combination lock; write a program which will simulate the behavior of the lock when five characters are entered. The actions are unlock $($ if correct sequence entered $)$ and an alarm $($ if the incorrect sequence is entered $).$ A table ADT must be used to store the transition table and action table of the finite state machine $($FSM$)$ which models the behavior of the lock. The correct combination will be given in a file. You should define the following

typedef enum STATE

$\{$

nke, ok$1,$ ok$2,$ ok$3,$ fa$1,$ fa$2,$ fa$3$

$\}$ aState ;

typedef enum EVENT

$\{$

A$,$ B$,$ C$,$ D$,$ E$,$ F

$\}$ anEvent;

Thus your mapping function would look like

int mapping $($ const Pair p$)$;

and your transition table would be declared as

Table $$ Pair$$ STATE, EVENT$>,$ STATE$>$ transitionTable$($ sizeOfTable, transitionMap $)$;

Similarly for the action table.

Your Table class implementation must have the backing storage of a one$-$dimensional array.Two dimensional arrays are NOT permitted. "pair.h$"$

#ifndef PAIR$\_$H

#define PAIR$\_$H

$//$ more or less from STL library

$//$ found in and

template$$ class T$1,$ class T$2>$

class Pair

$\{$

public:

T$1$ first;

T$2$ second;

$//$ default constructor

Pair$()$: first$($ T$1()),$ second$($ T$2())$

$\{\}$

$//$ constructor that initializes first and second

Pair$($ const T$1$ v$1,$ const T$2$ v$2)$:

first$($v$1),$ second$($v$2)$

$\{\}$

$//$copy constructor

template$$ typename U$1,$ typename U$2>$

Pair $($ const Pair& X$)$

: first$($ X$.$first $),$ second$($ X$.$second $)$

$\{\}$

$//$ overload

template$$ typename U$1,$ typename U$2>$

Pair& operator$=($ const Pair& init $)$

$\{$

return $*$this $=$ Pair$($init$)$;

$\}$

$//$ overload $$

friend bool operator$<mtext\; id="EditorElement\_8541298"></mtext><mi\; id="EditorElement\_8541299">(</mi>$ const Pair& lhs$,$ const Pair& rhs $)$

$\{$

return lhs$.$first $$ rhs$.$first $||!($ rhs$.$first $$ lhs$.$first && lhs$.$second $$ rhs$.$second $)$;

$\}$

$//$ overload $==$

friend bool operator$==($ const Pair& lhs$,$ const Pair& rhs $)$

$\{$

return lhs$.$first $==$ rhs$.$first && lhs$.$second $==$ rhs$.$second ;

$\}$

$\}$;

template$$ class T$1,$ class T$2>$

Pair makePair$($ const T$1$& v$1,$ const T$2$& v$2)$

$\{$

return Pair$$ T$1,$ T$2>($v$1,$v$2)$;

$\}$

#endif

"table.h$"$

#ifndef TABLE$\_$H

#define TABLE$\_$H

#include

#include "pair.h$"//$ Pair class

$//$ implements a table containing key$/$value pairs.

$//$ a table does not contain multiple copies of the same item.

$//$ types T and Key must have a default constructor

template $$ class Key, typename T $>$

class Table

$\{$

public:

typedef Key key$\_$type;

$//$ for convenience

private:

$//$ table implemented using a one dimensional array of key$-$value pairs

int tableSize;

Pair$$ key$\_$type, T $>*$the$\_$table;

int $(*$Mapping$)($ Key k$)$;

$//$ Mapping is a function which maps keys to

$//$ an array index; ie a key to address mapping

$//$ the idea is that Mapping will act on a given key

$//$ in such a way as to return the relative postion

$//$ in the sequence at which we expect to find the key

$//$ Mapping will be used in the remove, add, lookup. $=$

$//$ member functions and copy constructor

public:

$//$ only for debugging

void print$()$;

Table$($ int n$,$ int $(*$map$)($ Key k$))$;

$//$ map is a function to map key to address

$//$ in the implementation

$//$ set the function ie have the code line

$//$ Mapping $=$ map;

$//$ populates table with default values

$//$ for the class Key and T

bool insert$($ Pair$$ Key, T $>$ kvpair $)$;

$//$ return true if item could be added to the

$//$ table; false if item was not added.

bool remove$($ const Key aKey $)$;

$//$ erase the key$/$value pair with the specified key

$//$ from the table and return if successful

$//$ removed item is replaced with default

$//$ values for Key and T

T lookUp $($const Key aKey$)$ ;

$//$ what if key not in table??

$//$need copy constructor

Table$($ const Table$$ Key, T $>$ &initTable $)$;

$//$need destructor

~Table$()$;

$//$need assignment operator

Table$$ Key, T $>$&

operator$=($const Table$$ Key, T $>$ &initTable $)$;

$\}$;

#include "table.t$"$

#endif

Action$\_$table.t and Transition$\_$table.t Below