main.cpp

//  Edward J Skrod
//  proj5, COP4530

#include <iostream>
#include <fstream>          // Filestream object
#include "cputime.h"        // For computing the time of functions
#include <unistd.h>         // For cputime
#include <iomanip>          // For output formatting
#include <vector>           // Used to store a temporary list of relevant plays
#include <string>
#include <cstdlib>          // for Exit
#include <sstream>          // To parse the input
#include "List.h"
#include "Play.h"           // lineData class and member functions
#include "HashTable.h"
//#include <unordered_set>
#include <tr1/unordered_set>

using namespace tr1;
using namespace std;

struct PlayHasher
// This struct is used to overload the () operator for the hash function
// used by the unordered_set
{
    unsigned int operator()( const Play &playObj ) const {
       
        unsigned int hash = 0;
    
        //cout << "Calling PlayHasher on: " << playObj << "\n"; // UnHide for testing
        string Key = playObj.getOffenseName() + playObj.getDefenseName();
        //cout << "Key is: " << Key << "\n"; // UnHide for testing
        
        for (unsigned int lcv = 0; lcv != Key.size(); ++lcv){
            hash = 37 * hash + (Key[lcv] - 'a' + 1 );
        }
        
        hash = hash  + playObj.getDown() + playObj.getYardsToGo();
        Key = playObj.getDescription();
        
        // Add the Description here
        for (unsigned int lcv = 0; lcv != Key.size(); ++lcv){
            
            hash += Key[lcv];
        }
        //cout << "Hash is: " << hash << "\n"; // UnHide for testing to see hash value
 
        return hash;
    }
};

// FUNCTIONS
void readData(const string fileName, string &FileContent);
void storeData(const string fn,  unordered_set<Play, PlayHasher> &dataRecord,
               const string &FileContent);
void storeData(const string fn,  HashTable &dataRecord,
               const string &FileContent);
void list(vector<string> &input, unordered_set<Play, PlayHasher> &dataRecord, vector<Play> &tempList);
void list(vector<string> &input, HashTable &dataRecord, vector<Play> &tempList);
void sortByRelevance(vector<Play> &dataRecord);

// GLOBAL CONSTANTS
const string LIST = "list";
const bool TEST = false;

int main(int argc, const char * argv[])
{
    double t1, t2;
    float timeToStore_myhash = 0.0;
    float timeToList_myhash = 0.0;
    float timeToList_myhash_MIN = 1000;  // Give this a large, impossible number to start.
    float timeToList_myhash_MAX = 0.0;
    float timeToList_myhash_TOTAL = 0.0;
    float timeToList_myhash_MEAN = 0.0;
    int listCount = 0;                  // Tracks the number of times that list is called.
    
    
    float timeToStore_myDS = 0.0;
    float timeToList_myDS = 0.0;
    float timeToList_myDS_MIN = 1000;
    float timeToList_myDS_MAX = 0.0;
    float timeToList_myDS_TOTAL = 0.0;
    float timeToList_myDS_MEAN = 0.0;
    

    if (argc < 2) {
        cerr << argv[0] << " Year-List\n";
        exit(1);
    }
  
    string fileName;                    // Stores the filename once parsed
    //fileName = "2002.csv";
    unordered_set<Play, PlayHasher> dataRecord;
    HashTable ht_dataRecord;
    string FileContent;
    
    // Read in the data
   for (int lcv = 1; lcv < argc; lcv++) {   // Set to the 2rd arg
    
   
        // Set the filename
       fileName = argv[lcv];
        
        // Add the relative path and the file extension
       fileName = fileName + ".csv";
        
        // Read data into a temporary file
        readData(fileName, FileContent);
    
       //MYDATASTRUCTURE store Data
       t1 = cputime();
       storeData(fileName, ht_dataRecord, FileContent);
       t2 = cputime();
       timeToStore_myDS += (t2 - t1);

       // MYHASH store Data
       t1 = cputime();
        storeData(fileName, dataRecord, FileContent);
       t2 = cputime();
        timeToStore_myhash += (t2 - t1);
   }
    
    //cout << "myhash size: " << dataRecord.size() << "\n";
    //cout << "mydatarecord size: " << ht_dataRecord.totalNumRecords() << "\n";
    
   
    string tempString;      // Temporary string to save the user's input
    vector <string> input;  // Container to store the user's input
    string subString;
    
    do {
        
        vector<Play> tempList_myhash, tempList_myDS;

        input.clear();      // clear previous iteration (if any)
        
        // Read the input from CIN
        getline(cin, tempString, '\n');
        
        istringstream * issPtr = new istringstream(tempString);
        *issPtr >> subString;
        while (*issPtr) {
            input.push_back(subString);
            *issPtr >> subString;
        }
        delete issPtr;
        
        // Respond to the user's command
        if (input[0] == LIST) {
            
            
            //cout << "Calling list() on myhash: \n";
            // MYHASH list
            t1 = cputime();
            list(input, dataRecord, tempList_myhash);
            t2 = cputime();
            timeToList_myhash = (t2 - t1);
            timeToList_myhash_TOTAL = timeToList_myhash_TOTAL + timeToList_myhash;
            
            //cout << "\nCalling list() on mydatastructure: \n";
            // MYDATASTRUCTURE list
            t1 = cputime();
            list(input, ht_dataRecord, tempList_myDS);
            t2 = cputime();
            timeToList_myDS = (t2 - t1);
            timeToList_myDS_TOTAL = timeToList_myDS_TOTAL + timeToList_myDS;
 
            // Track how many times the list function has been called
            ++listCount;
    
            // Print the plays
            vector<Play>::iterator itr_myhash, itr_myDS;
            int numPlaysToPrint = atoi(input[1].c_str());
            
             itr_myhash = tempList_myhash.begin();
             itr_myDS = tempList_myDS.begin();
             int counter = 0;
             while ((counter < numPlaysToPrint) && (itr_myhash != tempList_myhash.end())){
             
                cout << *itr_myhash;
                cout << *itr_myDS;
                cout << "\n";
             ++itr_myhash;
             ++itr_myDS;
             ++counter;
             
             }
            
       } else if (input[0] == "x") {
            //  exit out of loop
       } else {
            cout << "Invalid command.\n";
        }
        
        // Set minimum, max values for time
        if (timeToList_myhash > timeToList_myhash_MAX)
        { timeToList_myhash_MAX = timeToList_myhash; }
        
        if ((timeToList_myhash < timeToList_myhash_MIN) && timeToList_myhash != 0)
        {  timeToList_myhash_MIN = timeToList_myhash; }
        
        if (timeToList_myDS > timeToList_myDS_MAX)
        { timeToList_myDS_MAX = timeToList_myDS; }
        
        if ((timeToList_myDS < timeToList_myDS_MIN ) && timeToList_myDS != 0)
        { timeToList_myDS_MIN = timeToList_myDS; }
        
       // Clear the temporary lists before the list function is called again
       tempList_myhash.clear();
       tempList_myDS.clear();
     
    } while ((input[0] != "x")); // end while
  
    
    // CALCULATE THE MEAN TIME TO LIST
    if (listCount > 0) {
        
        timeToList_myhash_MEAN = timeToList_myhash_TOTAL / listCount;
        timeToList_myDS_MEAN = timeToList_myDS_TOTAL / listCount;
        
    } else {    // Set timeToList_MIN == 0 if list() is never called

        timeToList_myhash_MIN = 0.0;
        timeToList_myDS_MIN = 0.0;
    }
    
    
    //cout << "Listcount is: " << listCount << "\n";
    cout << fixed << setprecision(5);
    // print statistics on the performance of each data structure
   cout << "myhash: store " << timeToStore_myhash << " s, list: min " << timeToList_myhash_MIN
        << " s, max " << timeToList_myhash_MAX << " s, mean " << timeToList_myhash_MEAN << " s\n";
    
    
    cout << "mydatastructure: store " << timeToStore_myDS << " s, list: min " << timeToList_myDS_MIN
    << " s, max " << timeToList_myDS_MAX << " s, mean " << timeToList_myDS_MEAN << " s\n";
    
    return 0;
}

// ============================ FUNCTIONS ==================================
void readData(const string filename, string &FileContent )
// Opens a file and stores the information into one large string
// Function adapted from Prof. Srinivasan's Proj1 Solution
{
    // Clear file content from previous iteration
    FileContent.clear();
    
    ifstream inFile;
    inFile.open( filename.data(), ios::in|ios::binary|ios::ate);  // Get pointer at end of file
    
    ifstream::pos_type size;
   
    if (!inFile) {
        cout << "Error opening file: " << filename << ". Exiting program.\n" << endl;
        exit(1);
    }
    
    size = inFile.tellg();
    char * buffer = new char[static_cast<int>(size)];
    
    inFile.seekg(0, ios::beg);   // set pointer to beginning of file
    inFile.read(buffer, size);   // read the file contents
    
    FileContent.clear();
    FileContent.append(buffer, buffer + size);  // Read the file contents
    
    delete [] buffer;
    inFile.clear();
    inFile.close();
  
}


void storeData(const string filename, unordered_set<Play, PlayHasher> &dataRecord, const string &FileContent)
// Used by main()

{
    stringstream in(FileContent);
    string temp;
    
    getline(in, temp, (char) 10);             // Read in the first line and discard
    
    // Create temporay variables to store the data from the file.
    string tmpGameID, tmpQuarter, tmpMin, tmpSec, tmpOffenseName,
    tmpDefenseName, tmpDown, tmpYardsToGo, tmpStartLocation,
    tmpDescription, tmpOffscore, tmpDefscore, tmpSeason;
    
    int playCounter = 0;     // This is going to generate a unique number representing
                             // the order in which the plays were stored.
    
    // Read in the variables;  Priming read
    getline(in, tmpGameID, ',');
    
    while (!in.eof()){
        
        getline(in, tmpQuarter, ',');
        getline(in, tmpMin, ',');
        getline(in, tmpSec, ',');
        getline(in, tmpOffenseName, ',');
        getline(in, tmpDefenseName, ',');
        getline(in, tmpDown, ',');
        getline(in, tmpYardsToGo, ',');
        getline(in, tmpStartLocation, ',');
        getline(in, tmpDescription, ',');
        getline(in, tmpOffscore, ',');
        getline(in, tmpDefscore, ',');
        getline(in, tmpSeason);
        
        if ((tmpYardsToGo != "") && (tmpStartLocation != "") && (tmpDown != "") && (tmpOffenseName != ""))
        {
            Play tempPlay(tmpGameID, tmpQuarter, tmpMin, tmpSec,
                          tmpOffenseName, tmpDefenseName, tmpDown, tmpYardsToGo,
                          tmpStartLocation, tmpDescription, tmpOffscore, tmpDefscore,
                          tmpSeason, playCounter);
            //  If tmpDescription contains the necessary words, create a new
            // Play object and add it to dataRecord
            if (tempPlay.searchDescription()) {
              
                ++playCounter;
               dataRecord.insert(tempPlay);

            }
            else {  }
         
          }
        
        // Read in the next Line
        getline(in, tmpGameID, ',');
        
    } // End while(!inFile->eof();
    
 } // storeData()


void storeData(const string filename, HashTable &dataRecord, const string &FileContent)
// Used by main()
{
    stringstream in(FileContent);
    string temp;
    
    getline(in, temp, (char) 10);             // Read in the first line and discard
    

    int playCounter = 0;
    // Create temporay variables to store the data from the file.
    string tmpGameID, tmpQuarter, tmpMin, tmpSec, tmpOffenseName,
    tmpDefenseName, tmpDown, tmpYardsToGo, tmpStartLocation,
    tmpDescription, tmpOffscore, tmpDefscore, tmpSeason;
    
    // Read in the variables;  Priming read
    getline(in, tmpGameID, ',');
    
    while (!in.eof()){
        
        getline(in, tmpQuarter, ',');
        getline(in, tmpMin, ',');
        getline(in, tmpSec, ',');
        getline(in, tmpOffenseName, ',');
        getline(in, tmpDefenseName, ',');
        getline(in, tmpDown, ',');
        getline(in, tmpYardsToGo, ',');
        getline(in, tmpStartLocation, ',');
        getline(in, tmpDescription, ',');
        getline(in, tmpOffscore, ',');
        getline(in, tmpDefscore, ',');
        getline(in, tmpSeason);
        
        if ((tmpYardsToGo != "") && (tmpStartLocation != "") && (tmpDown != "") && (tmpOffenseName != ""))
        {
            Play tempPlay(tmpGameID, tmpQuarter, tmpMin, tmpSec,
                          tmpOffenseName, tmpDefenseName, tmpDown, tmpYardsToGo,
                          tmpStartLocation, tmpDescription, tmpOffscore, tmpDefscore,
                          tmpSeason, playCounter);
            
            //  If tmpDescription contains the necessary words, create a new
            // Play object and add it to dataRecord
            if (tempPlay.searchDescription()) {
                
                ++playCounter;
                dataRecord.insert(tempPlay);
                
            }
            else {  }
            
        }
        
        // Read in the next Line
        getline(in, tmpGameID, ',');
        
    } // End while(!inFile->eof();
    
} // storeData()

void list(vector<string> &input, unordered_set<Play, PlayHasher> &dataRecord, vector<Play> &tempList)
// Used by main()
{
    
    if (input.size() == 8) {
        
        // Convert to integers where necessary and store the input in variables
        int minRemaining = atoi(input[2].c_str());
        string offense = input[3];              // Stores the Offense Team Code
        string defense = input[4];
        int down = atoi(input[5].c_str());      // Down
        int togo = atoi(input[6].c_str());      // Yards to Go for a First Down
        int ydline = atoi(input[7].c_str());    //  Stores the starting yardline
        
        
        unordered_set<Play, PlayHasher>::iterator itr;
        float relevance = 0.0;
        
        for (itr = dataRecord.begin(); itr != dataRecord.end(); ++itr){
            
             if (itr->isSimilar(offense, down, togo, ydline)){
                
                relevance = itr->calculateRelevance(minRemaining, defense, togo, ydline);
                
                Play tempSimilarData(itr->getGameID(),
                                     itr->getQuarter(),
                                     itr->getMin(),
                                     itr->getSec(),
                                     itr->getOffenseName(),
                                     itr->getDefenseName(),
                                     itr->getDown(),
                                     itr->getYardsToGo(),
                                     itr->getStartLocation(),
                                     itr->getDescription(),
                                     itr->getOffscore(),
                                     itr->getDefscore(),
                                     itr->getSeason(),
                                     relevance,
                                     itr->getPlayDescription(),
                                     itr->getPlayCount()
                                     );
                
                tempList.push_back(tempSimilarData);
            }
       }
        
       if (tempList.size() > 1){   // No need to sort if size() is <= 1
            
            //cout << "Sorting...." << endl;
            sortByRelevance ( tempList );
            
        } else if (tempList.size() == 0) {
            cout << "No similar play\n";
        } else {  }
    } else {
        cout << "No similar play\n";
    }
} // End list()

void list(vector<string> &input, HashTable &dataRecord, vector<Play> &tempList)
// Used by main()
{
    
    if (input.size() == 8) {
        
        // Convert to integers where necessary and store the input in variables
        int minRemaining = atoi(input[2].c_str());
        string offense = input[3];              // Stores the Offense Team Code
        string defense = input[4];
        int down = atoi(input[5].c_str());      // Down
        int togo = atoi(input[6].c_str());      // Yards to Go for a First Down
        int ydline = atoi(input[7].c_str());    //  Stores the starting yardline
        
        // Calculate the bucket number
        int Key = dataRecord.myhash( offense, down );
        

        // Generate the List of Plays
        dataRecord.handleList(tempList, Key, minRemaining, offense, defense, down, togo, ydline);
        
        if (tempList.size() > 1){   // No need to sort if size() is <= 1
            
            //dataRecord.mergeSort(tempList);
            //cout << "Sorting...." << endl;
            sortByRelevance ( tempList );
            
        } else if (tempList.size() == 0) {
            cout << "No similar play\n";
        } else {  }
        
    } else {
        cout << "No similar play\n";
    }
} // End list()


void sortByRelevance(vector<Play> &dR)
// Used by list()
// Sorts the vector by relevance in decending order from largest to smallest
{
    vector<Play>::iterator start;
    vector<Play>::iterator largest;
    vector<Play>::iterator current;
    
    Play temp;	            // Temp type is basetype of array
                            // Temporary storage during swap
    
    // Perform (numVectorElements - 1)  iterations
    for (start = dR.begin(); start < (dR.end() - 1); start++) {
        
        largest = start;
        
        // Scan the unsorted part of the array to find the smallest title
        for (current = (start + 1); current < dR.end(); current++)
        {
            if ((current->getRelevance() >= largest->getRelevance())) {
                
                if (current->getRelevance() > largest->getRelevance()){
                    largest = current;
                    
                } else if ((current->getRelevance() == largest->getRelevance()) && (current->getSeason() >= largest->getSeason())) {
                    
                    if (current->getSeason() > largest->getSeason()) {

                        largest = current;
                        
                    } else if (current->getSeason() == largest->getSeason()){
                    
                        if (current->getPlayCount() > largest->getPlayCount()) {
                            
                            largest = current;
                        } else { /* do nothing */ }
                        
                    } else { /* do nothing */ }
                    
                }
                else {}
                
            } // end if ((current->getRelevance() >= largest->getRelevance()))
            
        } // end for loop
        
        // Perform Exchage of array elements if necessary
        if (largest != start) {
            
            
            temp = *start;
            *start = *largest;
            *largest = temp;
            
            
            
         /*
            //  Temp = start
            temp.setGameID(start->getGameID());
            temp.setQuarter(start->getQuarter());
            temp.setMin(start->getMin());
            temp.setSec(start->getSec());
            temp.setOffenseName(start->getOffenseName());
            temp.setDefenseName(start->getDefenseName());
            temp.setDown(start->getDown());
            temp.setYardsToGo(start->getYardsToGo());
            temp.setStartLocation(start->getStartLocation());
            temp.setDescription(start->getDescription());
            temp.setRelevance(start->getRelevance());
            temp.setPlayDescription(start->getPlayDescription());
            temp.setPlayCount(start->getPlayCount());
            
            /// Start = Largest
            start->setGameID(largest->getGameID());
            start->setQuarter(largest->getQuarter());
            start->setMin(largest->getMin());
            start->setSec(largest->getSec());
            start->setOffenseName(largest->getOffenseName());
            start->setDefenseName(largest->getDefenseName());
            start->setDown(largest->getDown());
            start->setYardsToGo(largest->getYardsToGo());
            start->setStartLocation(largest->getStartLocation());
            start->setDescription(largest->getDescription());
            start->setRelevance(largest->getRelevance());
            start->setPlayDescription(largest->getPlayDescription());
            start->setPlayCount(largest->getPlayCount());

            
            // Largest = temp
            largest->setGameID(temp.getGameID());
            largest->setQuarter(temp.getQuarter());
            largest->setMin(temp.getMin());
            largest->setSec(temp.getSec());
            largest->setOffenseName(temp.getOffenseName());
            largest->setDefenseName(temp.getDefenseName());
            largest->setDown(temp.getDown());
            largest->setYardsToGo(temp.getYardsToGo());
            largest->setStartLocation(temp.getStartLocation());
            largest->setDescription(temp.getDescription());
            largest->setRelevance(temp.getRelevance());
            largest->setPlayDescription(temp.getPlayDescription());
            largest->setPlayCount(temp.getPlayCount());
*/
            
        }
    }  // end for loop
}