header
//-----------------------------------------------
// structDemo
//
// Demonstrate a record (struct) in C++.
//
// D. Searls
// Asbury College
// Oct 2009
//-----------------------------------------------

#include <iostream>
#include <iomanip>
using namespace std;

struct employeeRecord  // Declare an employee record data type
{
    string identifier;
    double hours;
    double wageRate;
    double grossPay;
};

const double MAXHOURS = 40.0;
const double OT_MULTIPLIER = 1.5;

int main()
{
    employeeRecord employee;
    
    // Get Employee Data

    cout << "Enter employee ID: ";
    cin >> employee.identifier;
    cout << "Enter hourly wage: ";
    cin >> employee.wageRate;
    cout << "Enter hours worked: ";
    cin >> employee.hours;
    cout << endl << endl;
    
    // Calculate Gross Pay
    
    if (employee.hours <= MAXHOURS)
    {
        employee.grossPay = employee.hours * employee.wageRate;
    }
    else
    {
        employee.grossPay = MAXHOURS * employee.wageRate
                            + (employee.hours - MAXHOURS)
                            * OT_MULTIPLIER * employee.wageRate;
    }
    
    // Display Employee ID and gross pay

    cout << fixed << setprecision(2);
    cout << "Gross pay for employee " << employee.identifier
         << " is " << employee.grossPay
         << endl << endl;

    return 0;
}


//-----------------------------------------------
// structDemo2
//
// Demonstrate using a record (struct) as a
// parameter in C++.
//
// D. Searls
// Asbury College
// Oct 2009
//-----------------------------------------------

#include <iostream>
#include <iomanip>
using namespace std;

struct employeeRecord  // Declare an employee record data type
{
    string identifier;
    double hours;
    double wageRate;
    double grossPay;
};


const double MAXHOURS = 40.0;
const double OT_MULTIPLIER = 1.5;

//-----------------------------------------------
// getData
//
// Get the employee data from the keyboard.
//
// Out Parameter: empData
//-----------------------------------------------
void getData(employeeRecord& empData)
{
    cout << "Enter employee ID: ";
    cin >> empData.identifier;
    cout << "Enter hourly wage: ";
    cin >> empData.wageRate;
    cout << "Enter hours worked: ";
    cin >> empData.hours;
    cout << endl << endl;
}

//-----------------------------------------------
// calculateGrossPay
//
// calculate the gross pay of the employee.
//
// In/Out Parameter: employee
//-----------------------------------------------
void calculateGrossPay(employeeRecord& employee)
{
    double regPay; // Regular pay
    double otPay;  // Overtime pay
    
    if (employee.hours <= MAXHOURS)
    {
        regPay = employee.hours * employee.wageRate;
        otPay = 0.0;
    }
    else
    {
        regPay = MAXHOURS * employee.wageRate;
        otPay = (employee.hours - MAXHOURS)
                 * OT_MULTIPLIER * employee.wageRate;
    }
    
    employee.grossPay = regPay + otPay;
}

//-----------------------------------------------
// displayReport
//
// Display a report showing the employee ID and
// gross pay.
//
// In Parameter: emp
//-----------------------------------------------
void displayReport(employeeRecord emp)
{
    cout << fixed << setprecision(2);
    cout << "Gross pay for employee " << emp.identifier
         << " is " << emp.grossPay
         << endl << endl;
}

//***********************************************
//              M A I N   D R I V E R
//***********************************************

int main()
{
    employeeRecord employee;
    
    getData(employee);
    calculateGrossPay(employee);
    displayReport(employee);

    return 0;
}


//-----------------------------------------------
// structDemo3
//
// Demonstrate an array of records (structs) in C++.
//
// D. Searls
// Asbury College
// Oct 2009
//-----------------------------------------------

#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;

struct employeeRecord  // Declare an employee record data type
{
    string identifier;
    double hours;
    double wageRate;
    double grossPay;
};


const double MAXHOURS = 40.0;
const double OT_MULTIPLIER = 1.5;
const int CAPACITY = 100;

//-----------------------------------------------
// getData
//
// Get the employee data from a file.
//
// Out Parameters: empData, n
//-----------------------------------------------
void getData(employeeRecord empData[], int& n)
{
    ifstream infile;
    string ident;
    double hours;
    double wage;
    
    infile.open("employeeData.txt");
    n = 0;
    infile >> ident >> wage >> hours;
    while (!infile.fail() && n < CAPACITY)
    {
        empData[n].identifier = ident;
        empData[n].hours = hours;
        empData[n].wageRate = wage;
        n++;
        
        infile >> ident >> wage >> hours;
    }
    infile.close();
}

//-----------------------------------------------
// calculateGrossPay
//
// Calculate the gross pay of each employee.
//
// In/Out Parameter: empList
//
// In Parameter: n
//-----------------------------------------------
void calculateGrossPay(employeeRecord empList[], int n)
{
    double regPay; // Regular pay
    double otPay;  // Overtime pay
    
    for (int i = 0; i < n; i++)
    {
    	if (empList[i].hours <= MAXHOURS)
        {
            regPay = empList[i].hours * empList[i].wageRate;
            otPay = 0.0;
        }
        else
        {
            regPay = MAXHOURS * empList[i].wageRate;
            otPay = (empList[i].hours - MAXHOURS)
                     * OT_MULTIPLIER * empList[i].wageRate;
        }
        
        empList[i].grossPay = regPay + otPay;    
    }
}

//-----------------------------------------------
// displayReport
//
// Display a report showing the employee ID and
// gross pay for each employee.
//
// In Parameters: emp, n
//-----------------------------------------------
void displayReport(const employeeRecord emp[], int n)
{
    cout << fixed << setprecision(2);
    cout << " ID   Gross Pay" << endl;
    cout << "----  ---------" << endl;
    
    for (int i = 0; i < n; i++)
    {
        cout << left << setw(4) << emp[i].identifier;
        cout << right << setw(11) << emp[i].grossPay;
        cout << endl;
    }
    cout << endl;
}

//***********************************************
//              M A I N   D R I V E R
//***********************************************

int main()
{
    employeeRecord employee[CAPACITY];
    int n;
    
    getData(employee, n);
    calculateGrossPay(employee, n);
    displayReport(employee, n);

    return 0;
}