Add files via upload

Author: gmook9

EntityInstance.cpp

@@ -0,0 +1,103 @@
+//
+// Created by gmook on 4/2/2021.
+//
+
+#include "EntityInstance.hpp"
+#include <iostream>
+#include <iomanip>
+
+
+void EntityInstance::print(int numSpaces, bool addComma) {
+    // Printing a instance within a set
+    // Instance is represented by { }
+    std::cout  << std::setw(numSpaces-1) << "{" << std::endl;
+    for (int i = 0; i < numAttributes(); i++) {
+        // Create a variable that represents the last element
+        int last = numAttributes() - 1;
+        // Check if we are at the last attribute with a IF
+        if (i == last) {
+            // If we are at the last attribute then do not add a comma
+            // we do this by setting addComma to false by passing it
+            // with the print function call
+            entityPairs.at(i).print(7, false);
+        } else {
+            // However, if we are not at the last attribute
+            // add a comma by passing true with the print function call
+            entityPairs.at(i).print(7, true);
+        }
+    }
+        if(addComma) {
+            // If the addComma boolean flag is set to true
+            // then we simply add a comma to the end of }
+            std::cout << std::setw(numSpaces) << "}," << std::endl;
+        }
+            else {
+                // If the boolean addComma flag is set to false then remember
+                // the comma takes up a extra space when printing. Since not adding comma
+                // be sure to setw to setw(numSpaces - 1) in order to have
+                // the correct alignment
+            std::cout << std::setw(numSpaces - 1) << "}" << std::endl;
+        }
+
+}
+
+// Function of STRING datatype because it is used to
+// return a ID which is off STRING datatype
+std::string EntityInstance::locateId() {
+    //********
+    // This functions will be similar to the locateGpa() function
+    // because they both same the same goal, however, instead of a double(GPA)
+    // this function will retrieve and return a string(ID).
+    //********
+    // Start by creating a variable of string datatype that can hold
+    // the retrieved IDs
+    std::string locateId;
+    // Create a loop that goes over each element in the entityPairs vector
+    for(int i = 0; i < entityPairs.size(); i++) {
+        // Set the string we just created equal to a function from
+        // the Pair class called locateId(). locateId() will
+        // return _attributeStringValue when a previous token "ID" is found
+        locateId = entityPairs.at(i).locateId();
+        // We create a boolean in the Pair class called foundTheId() this acts
+        // as a flag so we know when we locate a valid ID. If we find a valid ID using
+        // the Pair class function locateID() then the flag foundTheId() becomes true.
+        // Next, we simply set a test to say if(we found a ID from Pair) then break out of the loop
+        if(entityPairs.at(i).foundTheId())
+            break;
+    }
+    // Once broken out of the loop simply return the _attributeStringValue that was found and
+    // set equal to locateId
+    return locateId;
+}
+
+
+void EntityInstance::addPair(Pair &pair) {
+    entityPairs.push_back(pair);
+}
+
+int EntityInstance::numAttributes() {
+    return entityPairs.size();
+}
+
+// Function of DOUBLE datatype because we want to return a GPA
+// which is of DOUBLE datatype
+double EntityInstance::locateGpa() {
+    // create a variable of double datatype to hold GPAs
+    double locateGpa;
+    // Next create a loop that can through through all pairs in the
+    // entityPairs vector
+    for (int i = 0; i < entityPairs.size(); i++) {
+        // locateGpa() is a function inside of the Pair class
+        // when it is called on it will return the _attributeNumberValue
+        // at the selected pair
+        locateGpa = entityPairs.at(i).locateGpa();
+        // If the GPA is retrieved successfully, meaning its not 0
+        //  then we simply break out of the loop and return
+        // the retrieved GPA
+        if (locateGpa != 0)
+            break;
+    }
+    // return the GPA > 0 that we just pulled from the Pair class
+    return locateGpa;
+}
+

EntityInstance.hpp

@@ -0,0 +1,23 @@
+//
+// Created by gmook on 4/7/2021.
+//
+
+#ifndef P3P2_ENTITYINSTANCE_HPP
+#define P3P2_ENTITYINSTANCE_HPP
+
+#include <string>
+#include <vector>
+#include "Pair.hpp"
+
+class EntityInstance {
+public:
+    void addPair(Pair &pair);
+    int numAttributes();
+    void print(int numSpaces, bool addComma);
+    double locateGpa();
+    std::string locateId();
+private:
+    std::vector<Pair> entityPairs;
+};
+
+#endif //P3P2_ENTITYINSTANCE_HPP

EntitySet.cpp

@@ -0,0 +1,33 @@
+//
+// Created by gmook on 4/2/2021.
+//
+#include <iostream>
+#include "EntitySet.hpp"
+
+//Constructor
+EntitySet::EntitySet() {
+}
+
+void EntitySet::setterForMatrix(std::vector<std::pair<std::string, double>> settingMatrix) {
+    currentMatrix = settingMatrix;
+}
+
+std::vector<std::pair<std::string, double>> EntitySet::getterForMatrix() {
+    return currentMatrix;
+}
+
+void EntitySet::addEntity(EntityInstance &entityInstance) {
+    instances.push_back(entityInstance);
+}
+
+void EntitySet::print() {
+    std::cout << "[" << std::endl;
+    for(int i = 0; i < instances.size(); i++) {
+       int last = instances.size() - 1;
+        if(i == last)
+            instances.at(i).print(5,false);
+        else
+            instances.at(i).print(5, true);
+    }
+    std::cout << "]" << std::endl;
+}

EntitySet.hpp

@@ -0,0 +1,27 @@
+//
+// Created by gmook on 4/7/2021.
+//
+
+#ifndef P3P2_ENTITYSET_HPP
+#define P3P2_ENTITYSET_HPP
+
+
+
+#include <vector>
+#include "EntityInstance.hpp"
+
+class EntitySet {
+public:
+    EntitySet();
+    void setterForMatrix(std::vector<std::pair<std::string, double>>);
+    std::vector<std::pair<std::string, double>> getterForMatrix();
+    void addEntity(EntityInstance &);
+    void print();
+
+private:
+    std::vector<EntityInstance> instances;
+    std::vector<std::pair<std::string, double>> currentMatrix;
+};
+
+
+#endif //P3P2_ENTITYSET_HPP

JSONParser.cpp

@@ -0,0 +1,152 @@
+//
+// Created by gmook on 4/2/2021.
+//
+
+#include "JSONParser.hpp"
+
+JSONParser::JSONParser(JSONTokenizer &tokenizer): tokenizer{tokenizer} {}
+
+Pair JSONParser::parseAPair(){
+    // Create a instance of JSONToken called token
+    // and populate it with a token from tokenizer
+    // using getToken()
+    JSONToken token = tokenizer.getToken();
+    // DO a check to see if the token received is of string datatype.
+    // We know something is of string datatype because we are not reading the data
+    // the tokenizer has already done that. Instead we are checking the tokens. Each time
+    // a token has been made a boolean is changed alongside of its creation. For instance, when a "ID" token is found
+    // it sets a boolean called retrieveString() to be true. Therefore, we can use these boolean flags to make checks
+    // and further parse the data.
+    if(!token.retrieveString()){
+        // If not a string then exit
+        // Everything below is part of a error message
+        std::cout << "EXITING: parseAPair expected string, but instead received: " << std::endl;
+        std::cout << "-----> ";
+        token.print();
+        std::cout << " <-----";
+        exit(9);
+    }
+    // When the first IF statement does not hit that means a string is found. Therefore,
+    // create a variable of string datatype that stores the string. A function has already
+    // been built out inside of the token class to get this string and that function is fetchQuotedString()
+    std::string firstPartOfPair = token.fetchQuotedString();
+    // Get next token using getToken()
+    token = tokenizer.getToken();
+    if(!token.boolCreateColonJsonToken()){
+        // If not a colon then exit
+        // Everything below is part of a error message
+        std::cout << "EXITING: parseAPair expected colon, but instead received: " << std::endl;
+        std::cout << "-----> ";
+        token.print();
+        std::cout << " <-----";
+        exit(9);
+    }
+    // Get next token using getToken()
+    // Allows us to discard ":" since this is
+    // not a token we have to save
+    token = tokenizer.getToken();
+
+    // IF the token is a GPA
+    if(token.gpaF()){
+        // Create a variable of double datatype set it equal
+        // to the GPA using a function from token that returns gpa
+        double secondPartOfPair = token.grabGPA();
+        // We already have the first value of the pair so we insert our
+        // newly created double into the second value of the pair
+        Pair pair(firstPartOfPair, secondPartOfPair);
+        return pair;
+    }
+    //IF the token is a string
+    else if(token.retrieveString()){
+        // Create a new variable with a datatype string
+        // use the function from token to retrieve the string and set
+        // it equal to that string
+        std::string secondPartOfPair = token.fetchQuotedString();
+        // We already have the first value of the pair so we insert our
+        // newly created string into the second value of the pair
+        Pair pair(firstPartOfPair, secondPartOfPair);
+        return pair;
+    }
+    else{
+        std::cout << "EXITING: Neither a string or double datatype were found:";
+        std::cout << "-----> ";
+        token.print();
+        std::cout << " <----- ";
+        exit(9);
+    }
+}
+
+// This ENTIRE function was given by Professor
+// It is used as a model for parseAPair and parseJSONEntity
+// However, it is pretty much replicated in order
+// to make parseJSONEntity because it holds the same structure
+EntityInstance JSONParser::parseJSONObject() {
+    // parseJSONObject is responsible for parsing a JSON object. As such,
+    // the first token is expected to be an open brace.
+    JSONToken token = tokenizer.getToken();
+    if( ! token.boolCreateOpenCurlyJsonToken() ) {
+        std::cout << "Error: JSONParser::parseJSONObject: Expected an open brace, but found" << std::endl;
+        token.print();
+        std::cout << "Terminating..." << std::endl;
+        exit(1);
+    }
+    EntityInstance instance;
+    do {
+        Pair pair = parseAPair();
+        instance.addPair(pair);
+        token = tokenizer.getToken();
+    } while( token.boolCreateCommaJsonToken() );  // after having read a pair, we expect a comma
+    // So, the above loop terminates when we did find a comma.
+    // that means we have parsed an entire object. In that case, token must contain
+    // the close brace of that object.
+    if( ! token.boolCreateClosedCurlyJsonToken() ) {
+        std::cout << "Error: JSONParser::parseJSONObject: Expected a close brace, but found" << std::endl;
+        token.print();
+        std::cout << "Terminating..." << std::endl;
+        exit(1);
+    }
+
+    //**********MATRIX CREATION AID************
+    //1.
+    // Make a pair in the currentMatrix with ID and GPA
+    // Create a variable of datatype string that stores the ID
+    std::string existingID = instance.locateId();
+    //2.
+    // Create a variable of datatype double that stores GPA
+    double existingGPA = instance.locateGpa();
+    //1 & 2.
+    // Push back a pair into the currentMatrix
+    // std::make_pair MUST be used to create the pair of ID and GPA
+    currentMatrix.push_back(std::make_pair(existingID, existingGPA));
+    //******************************************
+    return instance;
+}
+
+// Similar to parseJSONObject()
+EntitySet JSONParser::parseJSONEntity(){
+    JSONToken token = tokenizer.getToken();
+    if(!token.boolCreateOpenSquareBracketJsonToken()){
+        std::cout << "EXITING: parseJSONEntity expected open bracket, instead:" << std::endl;
+        std::cout << "-----> ";
+        token.print();
+        std::cout << " <-----";
+        exit(9);
+    }
+    EntitySet set;
+    do{
+        EntityInstance instance = parseJSONObject();
+        set.addEntity(instance);
+        token = tokenizer.getToken();
+    } while(token.boolCreateCommaJsonToken());
+    if(!token.boolCreateClosedSquareBracketJsonToken()){
+        std::cout << "EXITING: parseJSONEntity expected close bracket, instead:" << std::endl;
+        std::cout << "-----> ";
+        token.print();
+        std::cout << " <-----";
+        exit(9);
+    }
+    set.setterForMatrix(currentMatrix);
+    return set;
+}
+
+

JSONParser.hpp

@@ -0,0 +1,27 @@
+//
+// Created by gmook on 4/7/2021.
+//
+
+#ifndef P3P2_JSONPARSER_HPP
+#define P3P2_JSONPARSER_HPP
+
+#include <string>
+#include <iostream>
+#include "EntityInstance.hpp"
+#include "JSONTokenizer.hpp"
+#include "EntitySet.hpp"
+
+class JSONParser {
+public:
+    JSONParser(JSONTokenizer &tokenizer);
+    Pair parseAPair();
+    EntityInstance parseJSONObject();
+    EntitySet parseJSONEntity();
+
+private:
+    JSONTokenizer &tokenizer;
+    std::vector<std::pair<std::string,double>> currentMatrix;
+};
+
+
+#endif //P3P2_JSONPARSER_HPP