main.cpp

Go to the documentation of this file.

#include <iostream>
#include <map>
#include <string>
#include <iostream>
#include <functional>
#include <exception>
#include <vector>

//
// supporting tools and software
//
// Validate and test your json commands
// https://jsonlint.com/

// RapidJSON : lots and lots of examples to help you use it properly
// https://github.com/Tencent/rapidjson
//

// std::function                    
// std::bind                       
// std::placeholders               
// std::map                        
// std::make_pair                  

#include "rapidjson/document.h"         // DOM API
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"

using namespace rapidjson;
using namespace std;
// namespace placeholders used in main()


// Operational globals. Do not change.
bool g_done = false;


// User globals. Ok to change.
bool TEST_ALL = true;        
bool VERBOSE = false;        
bool DEBUG = false;          



void debugPrinter(std::string id, std::string msg) {
    
    std::cerr << "***\tDEBUG from " << id << ": " 
              << msg << " \t***" << std::endl;
}



void exceptionPrinter(const char* excpt) {
    cout << "EXCEPTION: Oops, " << excpt 
         << ". Please try again." << endl; 
}



//
// TEST COMMANDS
//

auto fail_command = R"(
 {
  "command":"fail",
  "payload": {
     "Does not":"really matter what is in here."
  }
 }
)";


auto help_command = R"(
 {
  "command":"help",
  "payload": {
     "usage":"Enter json command in 'command':'<command>','payload': { // json payload of arguments }"
  }
 }
)";

auto help_command_fail = R"(
 {
  "command":"help",
  "payload": {
     "reason":"Not usage."
  }
 }
)";

auto exit_command = R"(
 {
  "command":"exit",
  "payload": {
     "reason":"Exiting program on user request."
  }
 }
)";

auto exit_command_fail = R"(
 {
  "command":"exit",
  "payload": {
     "booga":"gooba"
  }
 }
)";

auto sum_command = R"(
 {
  "command": "sum_ints",
  "payload": {
     "addends": [1, 2, 3]
  }
 }
)";

auto sum_command_long = R"(
 {
  "command": "sum_ints",
  "payload": {
     "addends": [1, 2, 3, 4, 5, 100, 999999999, -1, 0, -999]
  }
 }
)";

auto sum_command_floats = R"(
 {
  "command": "sum_ints",
  "payload": {
     "addends": [1, 2, 3, 4.5, 5.0, 100.1, 999999999.1, -1.1, 0, -999.1]
  }
 }
)";

auto sum_command_fail_1 = R"(
 {
  "command": "sum_ints",
  "payload": {
     "addends": ["apples", "oranges", "turtles"]
  }
 }
)";

auto sum_command_fail_2 = R"(
 {
  "command": "sum_ints",
  "payload": {
     "well":"formed",
     "json":"test"
  }
 }
)";

auto mean_command = R"(
 {
  "command": "mean_ints",
  "payload": {
     "addends": [1, 2, 3, 4, 5]
  }
 }
)";

auto mean_command_fraction = R"(
 {
  "command": "mean_ints",
  "payload": {
     "addends": [1, 2, 2]
  }
 }
)";

auto mean_command_long = R"(
 {
  "command": "mean_ints",
  "payload": {
     "addends": [1, 2, 3, 4, 5, 100, 999999999, -1, 0, -999]
  }
 }
)";

auto query_payload_command = R"(
 {
    "command": "query_payload",
    "payload": {
      "hello": "world",
      "t": true ,
      "f": false,
      "n": null,
      "i": 123,
      "pi": 3.1416,
      "a": [1, 2, 3, 4]
   }
 }
)";



class Controller {
public:

    bool help(rapidjson::Value &payload)
    {
        cout << "Controller::help: command: \n";
        
        // create iterator to look for "usage".
        rapidjson::Value::ConstMemberIterator itr = payload.FindMember("usage");

        // safely check for a value "usage"
        if (itr != payload.MemberEnd()) {

            // value exists. print to user
            cout << itr->value.GetString() << endl;
        }
        // if does not exist, throw exception
        else { 
            throw "no member \"usage\" present in payload JSON"; 
        }

        return true;
    }
    

    bool exit(rapidjson::Value &payload)
    {
        cout << "Controller::exit: command: \n";

        // create iterator to look for "reason".
        rapidjson::Value::ConstMemberIterator itr = payload.FindMember("reason");

        // safely check for a value "reason"
        if (itr != payload.MemberEnd()) {

            // value exists. print to user
            cout << itr->value.GetString() << endl;

            // terminate loop in main, causing controlled exit.
            g_done = true;

        }
        // if does not exist, throw exception
        else { 
            throw "no member \"reason\" present in payload JSON"; 
        }

        return true;
    }


    //
    // Additional commands below 
    //


    bool query_payload(rapidjson::Value &payload) 
    {
        cout << "Controller::payload_type command: \n";

        // array storing typenames
        static const char* kTypeNames[] = { 
            "Null", 
            "False", 
            "True", 
            "Object", 
            "Array", 
            "String", 
            "Number" 
        };
 
        for (Value::ConstMemberIterator itr = payload.MemberBegin();
                itr != payload.MemberEnd(); ++itr) {

            cout << "Type of member " << itr->name.GetString()
                 << " is " << kTypeNames[itr->value.GetType()] << endl;
        }

        return true;
    }



    bool sum_ints(rapidjson::Value &payload)
    {
        cout << "Controller::sum_ints command: \n";

        // create iterator to look for "addends".
        rapidjson::Value::ConstMemberIterator itr = payload.FindMember("addends");

        // safely check for a value "addends"
        if ( itr != payload.MemberEnd( )) {

            // value exists. check for array of numbers
            
            int num_ints = 0; // efficient vector allocation

            // reference for consecutive access
            const Value& a = payload["addends"];

            // make sure addends is an array. throw exception if not
            if ( ! a.IsArray() ) 
                throw "payload value \"addends\" is not an array";

            // initial loop for vector allocation optimization
            for ( auto& v : a.GetArray() ) {
                if (v.IsInt() ) {
                    ++num_ints;
                }
            }

            // if no integers in array, throw exception
            if ( num_ints == 0 )
                throw "no integers in array"; 

            // create vector and allocate
            vector<int> int_vect;
            int_vect.reserve(num_ints);

            int sum_i = 0;

            // loop through array again, filling vector
            for (auto& v : a.GetArray()) {

                // only add int elements
                if (v.IsInt()) {  
                    int_vect.push_back(v.GetInt());
                }
            }

            if(DEBUG) 
                cerr << "Made it past for loop in the int try" << endl;

            sum_i = summation(int_vect);

            cout << sum_i << endl;

        }
        // if does not exist, throw exception
        else { 
            throw "no member \"addends\" present in payload JSON"; 
        }

        return true;
    }



    bool mean_ints(rapidjson::Value &payload)
    {
        cout << "Controller::mean_ints command: \n";

        // create iterator to look for "addends".
        rapidjson::Value::ConstMemberIterator itr = payload.FindMember("addends");

        // safely check for a value "addends"
        if ( itr != payload.MemberEnd() ) {

            // value exists. check for array of numbers
            
            int num_ints = 0; // efficient vector allocation

            // reference for consecutive access
            const Value& a = payload["addends"];

            // make sure addends is an array. throw exception if not
            if ( ! a.IsArray() ) 
                throw "payload value \"addends\" is not an array";

            // initial loop for vector allocation optimization
            for ( auto& v : a.GetArray() ) {
                if ( v.IsInt() ) {
                    ++num_ints;
                }
            }

            // if no integers in array, throw exception
            if ( num_ints == 0 )
                throw "no integers in array"; 

            // create vector and allocate
            vector<int> int_vect;
            int_vect.reserve(num_ints);

            int sum_i = 0;

            // loop through array again, filling vector
            for ( auto& v : a.GetArray() ) {

                // only add int elements
                if ( v.IsInt() )  
                    int_vect.push_back(v.GetInt()); 
            }

            if(DEBUG) 
                cerr << "Made it past for loop in the int try" << endl;

            sum_i = summation(int_vect);

            cout << (sum_i/num_ints) << endl; 
        }
        // if does not exist, throw exception
        else { 
            throw "no member \"addends\" present in payload JSON"; 
        }

        return true;
    }




private:
    //static std::string CUR_SCOPE = "class Controller";     // DEBUG
    
    template<typename T>
    static auto summation(vector<T> collection) -> T {

        T sum = 0; // initialize 
        
        // loop through array
        for (auto& num : collection) {

            // add current number to sum
            sum += num;
        }

        if(DEBUG) 
            cerr << sum << endl;

        return sum;
    }
    
};



// Bonus Question: why did I type cast this?
//
// typedef: To make life easier
// typecast: To pass in a rapidjson::Value& and return a bool
//           I am more or less bypassing any false returns by throwing
//           exceptions, but true returns indicate that the command
//           was successfully handled.
typedef std::function<bool(rapidjson::Value &)> CommandHandler;



class CommandDispatcher {
public:
    // ctor - need impl
    CommandDispatcher()
    {
        // My implementation uses the default constructor.
        // I suspect that a more complex constructor might be needed if the map was
        // populated using a different method.
    }


    // dtor - need impl
    virtual ~CommandDispatcher()
    {
        // question why is it virtual? Is it needed in this case?
        //
        // Virtual refers to members that an inhereting class will implement that the
        // superclass does not implement, or to a member that the inhereting class will 
        // overload.
        //
        // I am not sure why this class would not have an explicit destructor but one of 
        // its inhereting classes would. I am not using inhereting classes for this. If
        // I was, perhaps this class would use the implicit destructor, but the inhereting 
        // classes would need more complex ones.
        //
        // In my case, I do not believe it is needed.
    }


    bool addCommandHandler(std::string command, CommandHandler handler)
    {
        cout << "CommandDispatcher: addCommandHandler: " << command << std::endl;

        bool add_succeeded = true;

        auto test = command_handlers_.insert( std::make_pair( command, handler));

        if( test.second == false) {
            cout << "Command " << command << " already existed. Addition failed" << endl;
            add_succeeded = false;
        }
        else {
            if(VERBOSE) {
                cout << "Command " << command << " added to map." << endl;
            }
        }

        return add_succeeded;
    }


    bool dispatchCommand(std::string command_json)
    {
        cout << "\n\nCOMMAND: " << command_json << endl;
        if(DEBUG) 
            debugPrinter(this->CUR_SCOPE, "made it to dispatchCommand"); 

        const char *command_ptr = command_json.c_str();  
        if(DEBUG) 
            debugPrinter(this->CUR_SCOPE, "made it past command_ptr");
        if(DEBUG) 
            debugPrinter(this->CUR_SCOPE, command_ptr);
 
        
        // parse the received string
        this->doc.Parse(command_ptr);
        if(DEBUG) 
            debugPrinter(this->CUR_SCOPE, "made it past doc.Parse");

        // check if JSON passed in. If not, throw error.
        if( this->doc.HasParseError() )  
            throw "malformed JSON"; 
        
        if(DEBUG) 
            debugPrinter(this->CUR_SCOPE, "made it past doc.HasParseError");


        // create iterators for "command" and "payload", if they exist.
        rapidjson::Value::ConstMemberIterator itr_c = this->doc.FindMember("command");
        rapidjson::Value::ConstMemberIterator itr_p = this->doc.FindMember("payload");


        // safely check for a value "command"
        if (itr_c != this->doc.MemberEnd()) {
            if(DEBUG)  
                debugPrinter(this->CUR_SCOPE, "made it into itr_c if"); 

            if(VERBOSE) {
                cout << "found command: " << itr_c->value.GetString() << endl;
            }
        }
        // if does not exist, throw exception
        else { 
            throw "no member \"command\" present in JSON"; 
        }


        // safely check for a value "payload"
        if (itr_p != this->doc.MemberEnd()) {
            if(DEBUG) 
                debugPrinter(this->CUR_SCOPE, "made it into itr_p if");

            if(VERBOSE) {
                // stringify the value
                StringBuffer buffer;
                Writer<StringBuffer> writer(buffer);
                itr_p->value.Accept(writer);

                cout << "found payload: " << buffer.GetString() << endl;
            }
        }
        // if does not exist, throw exception
        else { 
            throw "no member \"payload\" present in JSON"; 
        }


        if(DEBUG) 
            debugPrinter(this->CUR_SCOPE, "made it past iterators");

        // command routing
        bool command_found = false;  // until proven otherwise
        for( this->map_itr = command_handlers_.begin() ;
             this->map_itr != command_handlers_.end(); this->map_itr++ ) {

            // try to find match in map for command string
            if( itr_c->value.GetString() == (*map_itr).first ) {

                if(VERBOSE) {
                    cout << itr_c->value.GetString() << " matched a value in map!" << endl
                         << "Attempting to start command handler" << endl; 
                }

                command_found = true;
                
                // dispatch payload to command handler
                (*map_itr).second(this->doc["payload"]); 

                break; // don't keep looping longer than necessary
            }
        }

        // if command does not exist, throw exception
        if ( ! command_found) {
            if(DEBUG) 
                debugPrinter(this->CUR_SCOPE, "made it into ! command_found if");
            
            throw "no match for command found in map"; 
        }

        return command_found; // should always be true if execution falls through to here
    }


private:
    std::string CUR_SCOPE = "class CommandDispatcher";  // DEBUG - current scope

    std::map<std::string, CommandHandler> command_handlers_; 

    std::map<std::string, CommandHandler>::iterator map_itr = 

        this->command_handlers_.begin(); 

    rapidjson::Document doc;  // DOM API document

    // Question: why delete these?
    //
    // generate compile error if copy attempted
    // (supposed to be un-copyable)

    // delete unused constructors
    CommandDispatcher (const CommandDispatcher&) = delete;
    CommandDispatcher& operator= (const CommandDispatcher&) = delete;

};



int main()
{
    std::cout << "COMMAND DISPATCHER: STARTED" << std::endl;

    CommandDispatcher command_dispatcher;
    Controller controller;  // controller class of functions to "dispatch" from Command Dispatcher

    // bind controller functions to function objects to facilitate map addition
    //
    // std::placeholders::_1 refers to first (and only) argument for Controller member 
    // functions of type rapidjson::Value 
    using namespace placeholders;

    auto help_b =          std::bind( &Controller::help,          controller, _1 );
    auto exit_b =          std::bind( &Controller::exit,          controller, _1 );
    auto sum_ints_b =      std::bind( &Controller::sum_ints,      controller, _1 );
    auto query_payload_b = std::bind( &Controller::query_payload, controller, _1 );
    auto mean_ints_b =     std::bind( &Controller::mean_ints,     controller, _1 );

    // Add available command handlers in Controller class to CommandDispatcher manually
    command_dispatcher.addCommandHandler( "help",          help_b );
    command_dispatcher.addCommandHandler( "exit",          exit_b);
    command_dispatcher.addCommandHandler( "sum_ints",      sum_ints_b);
    command_dispatcher.addCommandHandler( "query_payload", query_payload_b); 
    command_dispatcher.addCommandHandler( "mean_ints",     mean_ints_b); 

    // DEBUG - should generate warning on fail because "help" already exists in map
    command_dispatcher.addCommandHandler( "help", help_b);

    
    // array of test commands
    string test_commands[] = {

        fail_command, // */
        
        help_command,
        help_command_fail, // */

        sum_command,
        sum_command_long,
        sum_command_floats, 
        sum_command_fail_1, 
        sum_command_fail_2, // */

        mean_command,
        mean_command_fraction,
        mean_command_long, // */

        query_payload_command, // */

        exit_command_fail/*, 
        exit_command // */

    };

    
    // if set, send all test commands to command dispatcher
    if (TEST_ALL) {

        for (auto& com : test_commands) {

            //catch and handle each exception
            try { 
                command_dispatcher.dispatchCommand(com); 
            }
            catch (const char* excpt) { 
                exceptionPrinter(excpt); 
            }  
        }
    }


    // command line interface for testing
    string command;
    while( ! g_done ) {
        cout << "\n\n\n";
        cout << "COMMANDS: {\"command\":\"exit\", \"payload\":{\"reason\":\"User requested exit.\"}}\n";
        cout << "\tenter command : ";
        getline(cin, command);
        try { 
            command_dispatcher.dispatchCommand(command); 
        }
        catch (const char* excpt) { 
            exceptionPrinter(excpt); 
        } 
    }

    std::cout << "COMMAND DISPATCHER: ENDED" << std::endl;
    return 0;
}