menuresp.C

Go to the documentation of this file.

#include "menuresp.h"

#include <iostream>
#include <iomanip>
#include <cstring>
#include <cctype>
#include "arrutil.h"
#include "genutil.h"

#define TEMPLATE_CLASSES_WONT_COMPILE
#include "array.h"

using namespace std;

MenuChoice::MenuChoice() : number(NULL), letters(NULL) { }

MenuChoice::MenuChoice(const char n[], const char L[])
   : number(new char [strlen(n)+1]), letters(new char [strlen(L)+1])
{
   if (number != NULL) {
      strcpy(number, n);
   }
   if (letters != NULL) {
      strcpy(letters, L);
   }
}

MenuChoice::MenuChoice(const MenuChoice & choice)
   : number(new char [strlen(choice.number)+1]),
     letters(new char [strlen(choice.letters)+1])
{
   if (number != NULL) {
      strcpy(number, choice.number);
   }
   if (letters != NULL) {
      strcpy(letters, choice.letters);
   }
}

MenuChoice::~MenuChoice() {
   delete [] number;
   number = NULL;
   delete [] letters;
   letters = NULL;
}

MenuChoice & MenuChoice::operator = (const MenuChoice & choice) {
   if (this != &choice)
   {
      delete [] number;
      number = new char [strlen(choice.number)+1];
      if (number != NULL) {
         strcpy(number, choice.number);
      }
      delete [] letters;
      letters = new char [strlen(choice.letters)+1];
      if (letters != NULL) {
         strcpy(letters, choice.letters);
      }
   }
   return *this;
}

bool MenuChoice::operator == (const MenuChoice & choice) const {
   return ((strcmp(number, choice.number) == 0) &&
           (strcmp(letters, choice.letters) == 0));
}

bool MenuChoice::operator == (const char choice[]) const {
   return ((strcmp(number, choice) == 0) ||
           (strstr(letters, choice) != NULL));  // allows phrase selection
}

bool MenuChoice::operator == (const char choice) const {
   return ((strchr(number, choice) != NULL) ||
           (strchr(letters, choice) != NULL));
}

MenuResponse::MenuResponse(const char menu_text[])
   : menu(new char [strlen(menu_text)+1]), valid_choices()
{
   if (menu != NULL) {
      strcpy(menu, menu_text);
      update_choices();
   }
}

MenuResponse::MenuResponse(const char * menu_text[], long items /* = 0 */)
   : menu(NULL), valid_choices()
{
   long chars, strs, s;
   if (items == 0) {
      strs = 0;
      while (menu_text[strs][0] != '\0') {
         strs++;
      }
   }
   else {
      strs = items;
   }
   if (strs > 0) {
      for (chars = 0, s = 0; s < strs; s++) {
         chars += strlen(menu_text[s]);
      }
      menu = new char [chars+1];
      if (menu != NULL) {
         strcpy(menu, menu_text[0]);  // they must supply the '\n' still...
         for (s = 1; s < strs; s++) {
            strcat(menu, menu_text[s]);
         }
         update_choices();
      }
   }
}

MenuResponse::MenuResponse(const MenuResponse & resp)
   : menu(new char [strlen(resp.menu)+1]), valid_choices()
{
   if (menu != NULL) {
      strcpy(menu, resp.menu);
      update_choices();
   }
}

MenuResponse::~MenuResponse() {
   delete [] menu;
   menu = NULL;
}

MenuResponse & MenuResponse::operator = (const MenuResponse & resp) {
   if (this != &resp)
   {
      delete [] menu;
      menu = new char [strlen(resp.menu)+1];
      if (menu != NULL) {
         strcpy(menu, resp.menu);
         update_choices();
      }
   }
   return *this;
}

void do_toupper(char & ch) {
   ch = toupper(ch);
   return;
}

long MenuResponse::get_response(void) const {
   char choice[12];
   long i;
//   isEqualTo(valid_choices[0],"howdy");
   cout << menu;
   cin >> setw(12) >> choice;
   for_each(choice, 0, strlen(choice)-1, do_toupper);
   i = find_if(valid_choices, 0, valid_choices.get_end(), (const char*)choice,
               isEqualTo<MenuChoice,const char*>);
               //isEqualTo<const MenuChoice &,const char*>);
   while (i < 0) {
      cout << "Invalid menu choice!" << endl << endl
           << menu;
      cin >> setw(12) >> choice;
      for_each(choice, 0, strlen(choice)-1, do_toupper);
      i = find_if(valid_choices, 0, valid_choices.get_end(),
                  (const char*)choice,
                  isEqualTo<MenuChoice,const char*>);
                  //isEqualTo<const MenuChoice &,const char*>);
   }
   return i;
}

// no + since it is often used in border corners
// the - is special
bool is_num_start(char x) {
   return (isdigit(x) || (x == '-')); // || (x == '+'));
}

void MenuResponse::update_choices(void) {
   char *num_start, *num_end, *cur, was, *caps;
   MenuChoice *item;
   long num_caps, cur_ch;

   // count new-lines and assume one choice per line (but there'll be more
   // new-lines than choices, most likely...
   valid_choices.resize(count_nonconseq_if(menu, 0, strlen(menu)-1, '\n',
                                           /*menu[0],*/ isEqualTo<char,char>));
   cur = menu;
   cur_ch = 0;
   while ((*cur != '\0') && (cur_ch < valid_choices.get_size())) {
      while ((*cur != '\0') && !is_num_start(*cur)) {
         cur++;
      }
      while ((is_num_start(*cur)) && (cur_ch < valid_choices.get_size())) {
         num_start = cur;
         do {
            cur++;
         } while (isdigit(*cur));  // '\0' isn't a digit
         num_end = cur;
         num_caps = 0;
         while ((*cur != '\0') && !is_num_start(*cur)) {
            if (isupper(*cur)) {
               num_caps++;          // count capital/highlighted letters
            }                // we should probably avoid duplicates,
                             // but that'd slow us down terribly...
            cur++;
         }
         caps = new char [num_caps+1];
         cur = num_end;
         num_caps = 0;
         while ((*cur != '\0') && !is_num_start(*cur)) {
            if (isupper(*cur)) {
               caps[num_caps++] = *cur;   // store/count cap/highlight letters
            }                // duplicate-removal would hurt here, too...
            cur++;
         }
         caps[num_caps] = '\0';
         was = '\0';
         ::swap(*num_end, was);  // null-terminate number within menu string
         item = new MenuChoice(num_start, caps);
         ::swap(*num_end, was);  // back to normal...
         valid_choices[cur_ch++] = *item;
         delete [] caps;
         delete item;  // item is a waste of dynamic alloc/realloc
                       // we should remove this, but would need more
                       // work on MenuChoice...later
      }
   }
   valid_choices.resize(cur_ch);  // shrink to only needed space
   return;
}

---