main.cpp

/** Start by copying in your code from part IV. 
 *  You need to finish part IV before starting
 *  part V.
 * 
 *  
 **/

#include <iostream> 
#include <fstream>
#include <cctype>
#define DEFAULT_DICT "dictionary1.txt"
#define DEFAULT_OUTPUT_FILE "dict-updated.txt"
#include "LinkedList.h"
#include "testll.h"
using namespace std;


enum Actions {QUIT, SHOW_WORD_COUNT, PRINT_TO_SCREEN, PRINT_TO_SCREEN_IN_REVERSE,
               ADD_WORD, LINEAR_SEARCH, DELETE_WORD, INSERT_IN_ORDER, SWAP,
               MERGE_DICTS, MERGE_SORT, LOAD_NEW_DICT, WRITE_DICT_TO_FILE, UNIT_TEST};  

const int min_menu_option = 1;   //not including Quit, which is zero
const int max_menu_option = UNIT_TEST;
const int min_dict_option = 1;
const int max_dict_option = 6;



int getMenuChoice();
void displayChoices();
void processInput(int userInt, LinkedList* currDict);
bool loadDict(LinkedList* currDict, string filename);
int getDictNum(const string& filename);

void loadDictPrompt(LinkedList* currdict);
string getDictName(int dictNum);
bool fileExists(const string& filename);

void writeToFile(LinkedList* currDict);

Node* findWord(LinkedList* currDict, string userWord);
void linearSearchPrompt(LinkedList* currDict);
void printSearchResult(Node* userNode, LinkedList* currDict);
void addWordPrompt(LinkedList* currDict);
string cleanInput(const string& userWord);

int main() 
{ 
   int userInt = -1; //random starter value out of range
   LinkedList* currDict = new LinkedList;
   loadDict(currDict, DEFAULT_DICT); //load default dictionary
   
   while (userInt != QUIT) {
      userInt = getMenuChoice();
      processInput(userInt, currDict);
   }

	return 0; 
}

string cleanInput(const string& userWord) {
   string final = "";
   
   for(unsigned int i = 0; i < userWord.length(); ++i) {
      if(isalpha(userWord.at(i))) {
         final.push_back(tolower(userWord.at(i)));
      }
   }
   
   return final;
}

void addWordPrompt(LinkedList* currDict) {
   string userWord;
   string cleanedInput;
   Node* userNode;
   cout << "Enter a word to add to the end of the chosen Dictionary: ";
   cin >> userWord;
   cleanedInput = cleanInput(userWord);
   cout << endl << "Your word was " << "'" << cleanedInput << "'." << endl;
   
   userNode = findWord(currDict, cleanedInput);
   if(userNode == nullptr) { //if not found
      cout << " We did not find your word." << endl;
      cout << " Adding word to dictionary...";
      //addWord(currDict, userWord); adds word in the right spot
      currDict->push_back(cleanedInput); //adds word to end
      cout << "        Added!";
      
      //print result after adding word
      printSearchResult(currDict->getLast(), currDict);
      //extra details
      cout << " There is no word after " << cleanedInput << ". It is the last word." << endl;
   } else { //if word found
      printSearchResult(userNode, currDict);
      if (userNode->getNext() == nullptr) {
         cout << " There is no word after " << cleanedInput << ". It is the last word." << endl;
      }
   }

}

void printSearchResult(Node* userNode, LinkedList* currDict) {
   if(userNode == nullptr) { //if not found
      cout << " We did not find your word." << endl;
   } else if (userNode == currDict->getLast()){ //if first
      cout << " The previous word would be '" << userNode->getPrev()->getData() << "'." << endl;
   } else if (userNode == currDict->getFirst()) { //if last
      cout << " The next word would be '" << userNode->getNext()->getData() << "'." << endl;
   } else { //if found inbetween first and last
      cout << " The previous word would be '" << userNode->getPrev()->getData() << "'." << endl;
      cout << " The next word would be '" << userNode->getNext()->getData() << "'." << endl;
   }
}

void linearSearchPrompt(LinkedList* currDict) {
   string userWord;
   Node* userNode = nullptr;
   cout << "Enter a word to find: ";
   cin >> userWord;
   userWord = cleanInput(userWord);
   cout << endl << "Your word was " << "'" << userWord << "'." << endl;
   
   userNode = findWord(currDict, userWord);
   printSearchResult(userNode, currDict);
}

Node * findWord (LinkedList * currDict, string userWord) {
   Node* current = currDict->getFirst();
   Node* location = nullptr;
   
   if (current != nullptr) { //if list is not empty
      do {
         if (current->getData() == userWord) { //if match found
            location = current; //store location
            break; //exit loop
         } else {
            current = current->getNext(); //increment node
         }
      } while (current != nullptr);
   }
   
   return location;
}

bool fileExists(const string& filename) { //taken from vector dict
   ifstream inFS;
   inFS.open(filename); //try to read from file
   bool exists = inFS.is_open(); //if successfully opened => file exists
   inFS.close();
   return exists;
}

void writeToFile(LinkedList* currDict) {
   string userIn;
   ofstream outFS;
   Node* current = currDict->getFirst(); //take head of list
   
   cout << "Enter name of file (.txt will be appended automatically), or enter 'd' to use default filename: ";
   cin >> userIn;
   cout << endl << endl; //for spacing
   
   if (userIn == "d") {
      userIn = DEFAULT_OUTPUT_FILE;
   } else {
      userIn = userIn + ".txt";
   }
   
   if (!fileExists(userIn)) {
      cout << "Writing to file ...";
      outFS.open(userIn);
      if (!outFS.is_open()) {
         cout << "error opening file to write";  
         return; //exit method
      } 
      
      while (current != nullptr) {
         outFS << current->getData() << endl;
         current = current->getNext();
      }
      outFS.close();  
      cout << "                   ...Done!";
   } else {
         cout << "ERROR! The file " << userIn << " already exists. No data was written to file." << endl;
      }
}

string getDictName(int dictNum) {
   return "dictionary" + to_string(dictNum) + ".txt"; //return given int's filename;
}


void loadDictPrompt(LinkedList* currDict) {
   int dictNum = getDictNum(currDict->getName()); //find current dictNum
   int userNum;
   
   bool leave = false;
   bool openedDict;
   while (!leave) {
      //take user input
      cout << "Which Dictionary should be opened? Enter a number from " << "\"" << min_dict_option << "\"" << " to " << "\"" << max_dict_option << "\"" << ": ";
      cin >> userNum;
      cout << endl; //for spacing
      
      if (userNum == dictNum) {
         cout << "That dictionary is already open! Pick another." << endl;
      } else if (userNum < min_dict_option || userNum > max_dict_option) {
         cout << "That number is not in the available range! Pick another." << endl;
      } else {
         openedDict = loadDict(currDict, getDictName(userNum)); //load appropriate dict
         leave = true; //leave while
      }
   }
   
   if (!openedDict) {
      cout << "ERROR! Cannot read chosen dictionary " << getDictName(userNum) << ". Dictionary  " << dictNum << " remains open." << endl;
   } else {
      cout << "Dictionary " << userNum << " is now open." << endl;
   }
}


int getDictNum(const string& filename) { //get dictnum int from dict name
   int dictNum = -1; // negative to indicate failure
   string::const_iterator itr = filename.begin();
   while (itr != filename.end()) { //iterate through string
      if (isdigit((*itr))) {
         dictNum = *itr - '0'; //initialize to first number encountered (finds int value by subtracting char values)
         break; //exit loop
      }
      ++itr;
   }
   
   return dictNum;
}
 
bool loadDict(LinkedList* currDict, string filename) {
   
   string currWord;
   ifstream inFS(filename);
   if (!inFS.is_open()) {
      return false;
   }
   
   currDict->clear(); //empty list
   
   //fill list
   while (!inFS.eof()) {
      inFS >> currWord;
      currDict->push_back(currWord);
   }
   
   inFS.close();
   currDict->setName(filename); //update current dict name
   return true;
}

void processInput(int userInt, LinkedList* currDict) {

   switch(userInt) {
      case QUIT:
         cout << "Thank you! Bye!" << endl;
         break;
      case SHOW_WORD_COUNT:
         cout <<  "There are " << currDict->size() << " words in dictionary #" << getDictNum(currDict->getName()) << ".";
         break;
      case PRINT_TO_SCREEN:
         currDict->print();
         break;
      case PRINT_TO_SCREEN_IN_REVERSE:
         currDict->print_reverse();
         break;
      case ADD_WORD:
         addWordPrompt(currDict);
         break;
      case LINEAR_SEARCH:
         linearSearchPrompt(currDict);
         break;
      case DELETE_WORD:
         cout << "    Coming soon!";
         break;
      case INSERT_IN_ORDER:
         cout << "    Coming soon!";
         break;
      case SWAP:
         cout << "    Coming soon!";
         break;
      case MERGE_DICTS:
         cout << "    Coming soon!";
         break;
      case MERGE_SORT:
         cout << "    Coming soon!";
         break;
      case LOAD_NEW_DICT:
         loadDictPrompt(currDict);
         break;
      case WRITE_DICT_TO_FILE:
         writeToFile(currDict);
         break;
      case UNIT_TEST:
         promptUnitTest();
         break;
   } 
}

int getMenuChoice() {
   int userInt;
   
   do {
      displayChoices();
      cin >> userInt;
      
      if ((userInt < min_menu_option || userInt > max_menu_option) && userInt != 0) {
         cout << "    Error! Input must be a number between " << min_menu_option << " and " << max_menu_option << ", or 0 to exit.";
      }
   } while ((userInt < min_menu_option || userInt > max_menu_option) && userInt != 0);
   
   return userInt;
   
}

void displayChoices() {
   cout << "--------------------------------------------" << endl;
   cout << "Options menu:" << endl;
   cout << "  (" << SHOW_WORD_COUNT << ") Count - get number of words in dictionary list\n";
   cout << "  (" << PRINT_TO_SCREEN << ") Print words to screen\n";
   cout << "  (" << PRINT_TO_SCREEN_IN_REVERSE << ") Print words to screen in reverse order\n";
   cout << "  (" << ADD_WORD << ") Add a word (to end of dictionary list)\n";
   cout << "  (" << LINEAR_SEARCH << ") Find a word (Linear Search)\n";
   cout << "  (" << DELETE_WORD << ") Find word, delete if found\n";
   cout << "  (" << INSERT_IN_ORDER << ") Find word, insert if not found (assumes words are sorted alphabetically)\n";
   cout << "  (" << SWAP << ") Swap two words\n";
   cout << "  (" << MERGE_DICTS << ") Merge two dictionaries (assumes words are sorted alphabetically)\n";
   cout << "  (" << MERGE_SORT << ") Sort words (Merge Sort)\n";
   cout << "  (" << LOAD_NEW_DICT << ") Load a dictionary (closes current dictionary)\n";
   cout << "  (" << WRITE_DICT_TO_FILE << ") Write current dictionary to file\n";
   cout << "  (" << UNIT_TEST << ") Unit test of data structure\n";
   cout << "Enter a number from " << SHOW_WORD_COUNT << " to " << UNIT_TEST << ", or " << QUIT << " to exit: ";
}