main.C

Go to the documentation of this file.

#include <iostream>
#include <cctype>

#include "input.h"
#include "arrutil.h"
#include "menuresp.h"

#include "employee.h"
#include "boss.h"

#define TEMPLATE_CLASSES_WONT_COMPILE
#include "commission.h"
#include "piece.h"
#include "hourly.h"
#include "array.h"

using namespace std;

// **************************  POINTER DELETION  ************************ //

template <typename Pointer>
void free_one(Pointer & ptr) {
   delete ptr;
   ptr = NULL;
   return;
}

// *****************************  PRINT ALL  **************************** //

void report_emp(const EmployeePtr & emp) {
   if (emp != NULL) {
      emp->print(cout);
      cout << " earned " << emp->earnings() << endl;
   }
   return;
}

// ****************************  EMPLOYEE ENTRY  ************************ //

void update_size(long size, long & max, bool & done) {
   char yn;
   done = false;
   if (size == max) {
      yn = get_in_set("YyNn",
                      "You have entered all the workers you can.\n"
                      "  Would you like to increase the size?  ",
                      "Yes or No, please...");
      if (toupper(yn) == 'Y') {
         max = get_bounded_lower(max+1, cin,
                                     "How many employees to handle now?  ",
                                 false, "");
      }
      else {
         done = true;
         cout << "Then you aren't allowed to enter anyone!!" << endl;
      }
   }
   return;
}

template <typename EmpPtrArray>
void do_entry_menu(EmpPtrArray & arr, long & size, long & max) {
   const long MAX_NAME = 50;

   double w, p;
   long q;
   char f[MAX_NAME], L[MAX_NAME];
   long choice;
   bool done;
   // note how backspace lets us use hidden choices
   // also we set 'E' to be ignored... (it would otherwise be
   // part of choice 5...
   MenuResponse entry_menu("+==============================+\n"
                           "| 1) enter Boss worker         |\n"
                           "| 2) enter Commissioned worker |\n"
                           "| 3) enter Piece worker        |\n"
                           "| 4) enter Hourly worker       |\n"
                           "| 5) Q\bReturn to Main Menu       |\n"
                           "+==============================+\n\n"
                           "-\bEnter choice:   ");

   update_size(size, max, done);
   while (!done) {
      choice = entry_menu.get_response();
      if (choice == 4) {
         done = true;
      }
      else {
         cout << "Enter name for worker (first last):  ";
         cin >> setw(MAX_NAME) >> f >> setw(MAX_NAME) >> L;
         switch (choice) {
         case 0: {
            cout << "Enter weekly wage:  ";
            cin >> w;
            arr[size] = new Boss(f, L, w);
         } break;
         case 1: {
            cout << "Enter weekly wage, commission rate, and quantity sold:  ";
            cin >> w >> p >> q;
            arr[size] = new CommissionWorker(f, L, w, p, q);
         } break;
         case 2: {
            cout << "Enter wage per piece and number of pieces:  ";
            cin >> w >> q;
            arr[size] = new PieceWorker(f, L, w, q);
         } break;
         case 3: {
            cout << "Enter hourly wage and hours worked:  ";
            cin >> w >> p;
            arr[size] = new HourlyWorker(f, L, w, p);
         } break;
         default: {    // for the - and E on 'Enter choice'
                       // MenuResponse handles rest...
            cout << "Invalid choice!" << endl;
         } break;
         }
         if (arr[size] != NULL) {
            size++;
         }
         update_size(size, max, done);
      }
   }
   return;
}

// *************************  WAGE STATS SUPPORT  *********************** //

enum CountType { Low, High, Both };

template <typename TypeBounded = double, typename BoundType = double>
class Count_If_Bounded {
   BoundType low, hi;
   CountType which_bounds;
   mutable long count;

public:
   Count_If_Bounded(BoundType L = 0.0, BoundType H = 0.0, CountType w = Low)
      : low(L), hi(H), which_bounds(w), count(0) { }
   Count_If_Bounded(const Count_If_Bounded & cib)
      : low(cib.low), hi(cib.hi), which_bounds(cib.which_bounds),
        count(cib.count) { }
   ~Count_If_Bounded() {}

   Count_If_Bounded & operator = (const Count_If_Bounded & cib) {
      low = cib.low;
      hi = cib.hi;
      which_bounds = cib.which_bounds;
      count = cib.count;
      return *this;
   }

   bool operator () (TypeBounded well) const {
      bool ans = false;
      if (((which_bounds == Low) && (well >= low)) ||
          ((which_bounds == High) && (well <= hi)) ||
          ((which_bounds == Both) && ((well <= hi) && (well >= low)))) {
         ans = true;
         count++;
      }
      return ans;
   }

   void set_count(long c = 0) { count = c; return; }
   void set_bounds(BoundType L, BoundType H, CountType w) {
      low = L;
      hi = H;
      which_bounds = w;
      count = 0;
   }
   long get_count(void) const { return count; }
};

template <>
class Count_If_Bounded<EmployeePtr> {
   double low, hi;
   CountType which_bounds;
   mutable long count;
public:
   Count_If_Bounded(double L = 0.0, double H = 0.0, CountType w = Low)
      : low(L), hi(H), which_bounds(w), count(0) { }
   Count_If_Bounded(const Count_If_Bounded & cib)
      : low(cib.low), hi(cib.hi), which_bounds(cib.which_bounds),
        count(cib.count) { }
   ~Count_If_Bounded() {}
   Count_If_Bounded & operator = (const Count_If_Bounded & cib) {
      low = cib.low;
      hi = cib.hi;
      which_bounds = cib.which_bounds;
      count = cib.count;
      return *this;
   }
   bool operator () (EmployeePtr well) const {
      bool ans = false;
      if (well != NULL) {
         if (((which_bounds == Low) && (well->earnings() >= low)) ||
             ((which_bounds == High) && (well->earnings() <= hi)) ||
             ((which_bounds == Both) && ((well->earnings() <= hi) &&
                                         (well->earnings() >= low)))) {
            ans = true;
            count++;
         }
      }
      return ans;
   }
   void set_count(long c = 0) { count = c; return; }
   void set_bounds(double L, double H, CountType w) {
      low = L;
      hi = H;
      which_bounds = w;
      count = 0;
   }
   long get_count(void) const { return count; }
};

typedef CountType PrintType;

template <typename TypeBounded = double, typename BoundType = double>
class Print_If_Bounded {
   BoundType low, hi;
   PrintType which_bounds;
   ostream & print_on;
   long wide;

public:
   Print_If_Bounded(BoundType L = 0.0, BoundType H = 0.0, PrintType w = Low,
                    long W = 5, ostream & o = cout)
      : low(L), hi(H), which_bounds(w), print_on(o), wide(W) { }
   Print_If_Bounded(const Print_If_Bounded & pib)
      : low(pib.low), hi(pib.hi), which_bounds(pib.which_bounds),
        print_on(pib.print_on), wide(pib.wide) { }
   ~Print_If_Bounded() {}

   Print_If_Bounded & operator = (const Print_If_Bounded & pib) {
      low = pib.low;
      hi = pib.hi;
      which_bounds = pib.which_bounds;
      wide = pib.wide;
     // cannot re-set print_on due to & rules
      return *this;
   }

   void operator () (TypeBounded well) const {
      if (((which_bounds == Low) && (well >= low)) ||
          ((which_bounds == High) && (well <= hi)) ||
          ((which_bounds == Both) && ((well <= hi) && (well >= low)))) {
         print_on << setw(wide) << well;
      }
      return;
   }
};

template <>
class Print_If_Bounded<EmployeePtr> {
   double low, hi;
   PrintType which_bounds;
   ostream & print_on;
   long wide;

public:
   Print_If_Bounded(double L = 0.0, double H = 0.0, PrintType w = Low,
                    long W = 5, ostream & o = cout)
      : low(L), hi(H), which_bounds(w), print_on(o), wide(W) { }
   Print_If_Bounded(const Print_If_Bounded & pib)
      : low(pib.low), hi(pib.hi), which_bounds(pib.which_bounds),
        print_on(pib.print_on), wide(pib.wide) { }
   ~Print_If_Bounded() {}
   Print_If_Bounded & operator = (const Print_If_Bounded & pib) {
      low = pib.low;
      hi = pib.hi;
      which_bounds = pib.which_bounds;
      wide = pib.wide;
      // cannot re-set print_on due to & rules
      return *this;
   }
   void operator () (EmployeePtr well) const {
      if (well != NULL) {
         if (((which_bounds == Low) && (well->earnings() >= low)) ||
             ((which_bounds == High) && (well->earnings() <= hi)) ||
             ((which_bounds == Both) && ((well->earnings() <= hi) &&
                                         (well->earnings() >= low)))) {
            well->print(print_on);
            print_on << " earned " << well->earnings() << endl;
         }
      }
      return;
   }
};

// **************************  WAGE STATISTICS  ************************* //

template <typename EmpPtrArray>
void do_wage_count_menu(EmpPtrArray arr, long size) {
   MenuResponse wage_count_menu("################################\n"
                                "# 1) count wages Above a limit #\n"
                                "# 2) count wages Below a limit #\n"
                                "# 3) count wages in a Range    #\n"
                                "################################\n\n"
                                "-\bEnter choice:  ");
   long choice;
   double limit1, limit2;
   Count_If_Bounded<EmployeePtr> count_em;

   choice = wage_count_menu.get_response();
   switch (choice) {
   case 0: {
      limit1 = get_bounded_lower(-1.0, cin,
                                "Enter (inclusive) limit for counting:  ");
      count_em.set_bounds(limit1, limit2, Low);
      for_each(arr, 0, size-1, count_em);
      cout << "Found " << count_em.get_count() << " personnell with "
           << "salaries above " << limit1 << "." << endl;
   } break;
   case 1: {
      limit2 = get_bounded_lower(-1.0, cin,
                                "Enter (inclusive) limit for counting:  ");
      count_em.set_bounds(limit1, limit2, High);
      for_each(arr, 0, size-1, count_em);
      cout << "Found " << count_em.get_count() << " personnell with "
           << "salaries below " << limit2 << "." << endl;
   } break;
   case 2: {
      limit1 = get_bounded_lower(-1.0, cin,
                                "Enter (inclusive) lower limit"
                                " for counting:  ");
      limit2 = get_bounded_lower(limit1, cin,
                                "Enter (inclusive) upper limit"
                                " for counting:  ");
      count_em.set_bounds(limit1, limit2, Both);
      for_each(arr, 0, size-1, count_em);
      cout << "Found " << count_em.get_count() << " personnell with "
           << "salaries between " << limit1 << " and " << limit2
           << "." << endl;
   } break;
   default: {
      cout << "Invalid choice!" << endl; // for - and E in 'Enter choice'
   } break;
   }
   return;
}

template <typename EmpPtrArray>
void do_wage_print_menu(EmpPtrArray arr, long size) {
   MenuResponse wage_print_menu("################################\n"
                                "# 1) print wages Above a limit #\n"
                                "# 2) print wages Below a limit #\n"
                                "# 3) print wages in a Range    #\n"
                                "################################\n\n"
                                "-\bEnter choice:  ");
   long choice;
   double limit1, limit2;

   choice = wage_print_menu.get_response();
   switch (choice) {
   case 0: {
      limit1 = get_bounded_lower(-1.0, cin,
                                "Enter (inclusive) limit for printing:  ");
      for_each(arr, 0, size-1,
               Print_If_Bounded<EmployeePtr>(limit1, limit2, Low));
   } break;
   case 1: {
      limit2 = get_bounded_lower(-1.0, cin,
                                "Enter (inclusive) limit for printing:  ");
      for_each(arr, 0, size-1,
               Print_If_Bounded<EmployeePtr>(limit1, limit2, High));
   } break;
   case 2: {
      limit1 = get_bounded_lower(-1.0, cin,
                                "Enter (inclusive) lower limit"
                                " for printing:  ");
      limit2 = get_bounded_lower(limit1, cin,
                                "Enter (inclusive) upper limit"
                                " for printing:  ");
      for_each(arr, 0, size-1,
               Print_If_Bounded<EmployeePtr>(limit1, limit2, Both));
   } break;
   default: {
      cout << "Invalid choice!" << endl; // for - and E in 'Enter choice'
   } break;
   }
   return;
}

template <typename EmpPtrArray>
void do_wage_menu(EmpPtrArray arr, long size) {
   MenuResponse wage_menu("############################\n"
                          "# 1) Print certain wages   #\n"
                          "# 2) Count certain wages   #\n"
                          "# 3) Q\bReturn to Main Menu   #\n"
                          "############################\n\n"
                          "-\bEnter choice:  ");
   long choice;
   bool done = false;
   choice = wage_menu.get_response();
   done = (choice == 2);
   while (!done) {
      switch(choice) {
      case 0: {
         do_wage_print_menu(arr, size);
      } break;
      case 1: {
         do_wage_count_menu(arr, size);
      } break;
      default: {
         cout << "Invalid choice!" << endl; // for - and E on 'Enter choice'
      } break;
      }
      choice = wage_menu.get_response();
      done = (choice == 2);
   }
   return;
}

// ****************************  MAIN MENU  ***************************** //

template <typename EmpPtrArray>
void do_main_menu(EmpPtrArray & arr, long & size, long & max) {
   MenuResponse main_menu("1) Enter new workers\n"
                          "2) Print workers out\n"
                          "3) Wage statistics\n"
                          "4) M\bR\bQuit program\n\n"
                          "-\bEnter choice:  ");
   long choice;
   bool done = false;
   choice = main_menu.get_response();
   done = (choice == 3);
   while (!done) {
      switch(choice) {
      case 0: {
         do_entry_menu(arr, size, max);
      } break;
      case 1: {
         for_each(arr, 0, size-1, report_emp);
      } break;
      case 2: {
         do_wage_menu(arr, size);
      } break;
      default: {
         cout << "Invalid choice!" << endl; // for the - on 'Enter choice'
      } break;
      }
      choice = main_menu.get_response();
      done = (choice == 3);
   }
   return;
}

// ****************************  MAIN PROGRAM  ************************** //

int main(void) {
   Array<EmployeePtr> arr;
   long cur_emp, max_emp;

   max_emp = get_bounded_lower(0, cin,
                               "How many employees to start?  ",
                               false, "");
   arr.resize(max_emp);
   for (cur_emp = 0; cur_emp < max_emp; cur_emp++) {
      arr[cur_emp] = NULL;
   }
   cur_emp = 0;
   do_main_menu(arr, cur_emp, max_emp);
   for_each(arr, 0, cur_emp-1, free_one<EmployeePtr>);

   cout << endl
        << "Thanks for using our employee program!" << endl
        << endl
        << "Come again soon!" << endl
        << endl;

   return 0;
}

---