#include "StdAfx.h"
#include <iostream>
#include <string>

// Include Number.h and MenuClass.h in the stdafx.h file instead of here.

// ==================

// ====================
 using namespace std;
// ====================

// ============
// Constructors
// ============

// ===================
// Default Constructor
// ==============================
classMenu::classMenu( void ) {

userMenuSelection = Quit;

} // Constructor Menu
// =====================

// ================
// End Constructors
// ================

// ==========
// Destructor
//
// NOTES:
// 1) The Menu constructor does not dynamically allocate space in the freestore.
// Thus, the destructor does not need to deallocate memory.
// ===========================================================
classMenu::~classMenu( void ) {
cout << "Destructor ~Menu invoked." << endl;

} // Destructor ~Menu
// =====================

// ==============
// End Destructor
// ==============

// ================
// Member-Functions
// ================

// ==============================
// Accessor Member-Function Get()
// ==========================
MenuChoices classMenu::Get( ) {

return userMenuSelection;

} // Accessor Method Get
// ========================

// =============================
// Mutator Member-Function Set()
// =============================================
void classMenu::Set( MenuChoices newValue ) {

userMenuSelection = newValue;

} // Mutator Method Set
// =======================
// ==========================
// Member-Function Display( )
// ============================
void classMenu::Display( ) {

cout << "1: Quit" << endl;
cout << "2: Sum"<< endl; 
cout <<	"3: Difference" << endl;
cout << "4: Product" << endl;
cout << "5: Quotient" << endl;

} // Member-Function Display
// ============================

// =========================
// Member-Function QueryUser
// ==============================
void classMenu::QueryUser( ) {

int selection;

cout << "Enter Menu Selection: ";

// =================================================
// Obtain from the user a menu selection number, and
// use that value to assign the corresponding enumerated
// value to the private member-variable userMenuSelection.
// =======================================================
cin >> selection;

switch (selection){
case 1: userMenuSelection = Quit;
break;

case 2: userMenuSelection = Sum;
break;

case 3: userMenuSelection = Difference;
break;

case 4: userMenuSelection = Product;
break;

case 5: userMenuSelection = Quotient;
break;

default: userMenuSelection = Quit;
} // switch
// ===========

cout << endl;

} // Method QueryUser()
// =======================

// =================
// Method Continue()
// =============================
bool classMenu::Continue( ) {

return userMenuSelection != Quit;

} // Method Continue
// ====================

// ==============================
// Member-Function ProcessCommand
// ===================================
void classMenu::ProcessCommand( ) {

int numA;
int numB;
Number numberA;
Number numberB;
Number numberC(0);

if ( userMenuSelection != Quit ){

// =====
// Input
// ===================================
cout << "Enter an integer value: ";
cin >> numA;
numberA.Set(numA);

cout << "Enter an integer value: ";
cin >> numB;
numberB.Set(numB);
cout << endl;
// =============

// ==============================
switch ( userMenuSelection ) {

case Sum: numberC.Add(numberA);
numberC.Add(numberB);
cout << numberA.Get() << " + " << numberB.Get() << " = "
 << numberC.Get() << endl;
break;

// =============
// STUDENT WORK:
case Difference: numberC.Subtract(numberA);
numberC.Subtract(numberB);
cout << numberA.Get() << " - " << numberB.Get() << " = "
 << numberC.Get() << endl; 
break;

case Product: numberC.Multiply(numberA);
	numberC.Multiply(numberB);
	cout << numberA.Get() << " * " << numberB.Get() << " = "
 << numberC.Get() << endl;
break;

case Quotient: numberC.Divide(numberA);
numberC.Divide(numberB);
cout << numberA.Get() << " / " << numberB.Get() << " = "
 << numberC.Get() << endl;
break;

default: cout << "Warning: error state encountered." << endl;
} // switch
// ===========

cout << endl;

} // then

} // Method ProcessCommand( )
// =============================

// ====================
// End Member-Functions
// =====================