program.cpp

Go to the documentation of this file.

 
 
#include <functional>
#include <iostream>
 
#include <version.h>
 
#include "helpers/replace.h"
#include "helpers/stringlist.h"
#include "helpers/enablevtmode.h"
 
#include "Adapter_Exercise.h"
#include "Bridge_Exercise.h"
#include "Command_Exercise.h"
#include "Composite_Exercise.h"
#include "Decorator_Exercise.h"
#include "Facade_Exercise.h"
#include "Flyweight_Exercise.h"
#include "HandlerChain_Exercise.h"
#include "Interpreter_Exercise.h"
#include "Iterator_Exercise.h"
#include "Mediator_Exercise.h"
#include "Memento_Exercise.h"
#include "NullObject_Exercise.h"
#include "Observer_Exercise.h"
#include "Proxy_Exercise.h"
#include "State_Exercise.h"
#include "Strategy_Exercise.h"
#include "Visitor_Exercise.h"
 
namespace DesignPatternExamples_cpp
{
 
    typedef std::function<void()> Action;
 
    class Program
    {
    private:
        struct Exercise
        {
            std::string name;
 
            Action exercise_to_run;
 
 
            Exercise(const char* nameOfExercise, Action exercise)
            {
                name = nameOfExercise;
                exercise_to_run = exercise;
            }
        };
 
        typedef std::vector<Exercise> ExerciseList;
 
        struct Options
        {
            StringList exercise_names;
        };
 
    private:
        void Help(ExerciseList exercises)
        {
            std::string usage =
                "{0} (v" APP_VERSION ") by Stephen P. Lepisto\n"
                "usage: {0} [options] [exercise_name][[ exercise_name][...]]\n"
                "\n"
                "Runs through a series of exercises showing off design patterns.  If no\n"
                "exercise_name is given, then run through all exercises.\n"
                "\n"
                "Options:\n"
                "--help, -?\n"
                "     This help text.\n"
                "--version\n"
                "     Show just the version number of this application.\n"
                "\n"
                ""; // End of string.
 
            std::string appName = "DesignPatternExamples_cpp";
            std::cout << Helpers::Replace(usage, "{0}", appName.c_str());
 
            std::cout << std::endl << "Exercises available:" << std::endl;
            for (Exercise exercise : exercises)
            {
                std::cout << "  " << exercise.name << std::endl;
            }
        }
 
        void ShowVersion()
        {
            std::cout << APP_VERSION << std::endl;
        }
 
        bool ParseOptions(StringList args, ExerciseList exercises, Options& options)
        {
            bool optionsValid = true;
 
            options.exercise_names.clear();
 
            if (args.size() > 0)
            {
                for (std::string argument : args)
                {
                    if (argument == "--help" ||
                        argument == "-?" ||
                        argument == "/?")
                    {
                        Help(exercises);
                        optionsValid = false;
                        break;
                    }
                    else if (argument == "--version")
                    {
                        ShowVersion();
                        optionsValid = false;
                        break;
                    }
                    options.exercise_names.push_back(argument);
                }
            }
 
            return optionsValid;
        }
 
    public:
        void Run(StringList args)
        {
            ExerciseList exercises
            {
                // We use a lambda here that auto-binds to the "this" pointer ("[&]")
                // for this object so as to avoid complicated declarations and
                // bindings to class methods.
                Exercise("Adapter", [&] { Adapter_Exercise(); }),
                Exercise("Bridge",  [&] { Bridge_Exercise(); }),
                Exercise("Command",  [&] { Command_Exercise(); }),
                Exercise("Composite",  [&] { Composite_Exercise(); }),
                Exercise("Decorator",  [&] { Decorator_Exercise(); }),
                Exercise("Facade",  [&] { Facade_Exercise(); }),
                Exercise("Flyweight",  [&] { Flyweight_Exercise(); }),
                Exercise("HandlerChain",  [&] { HandlerChain_Exercise(); }),
                Exercise("Interpreter",  [&] { Interpreter_Exercise(); }),
                Exercise("Iterator",  [&] { Iterator_Exercise(); }),
                Exercise("Mediator",  [&] { Mediator_Exercise(); }),
                Exercise("Memento",  [&] { Memento_Exercise(); }),
                Exercise("NullObject",  [&] { NullObject_Exercise(); }),
                Exercise("Observer",  [&] { Observer_Exercise(); }),
                Exercise("Proxy",  [&] { Proxy_Exercise(); }),
                Exercise("State",  [&] { State_Exercise(); }),
                Exercise("Strategy",  [&] { Strategy_Exercise(); }),
                Exercise("Visitor",  [&] { Visitor_Exercise(); }),
            };
 
            Options options;
            if (ParseOptions(args, exercises, options))
            {
                for (Exercise exercise : exercises)
                {
                    bool runExercise = options.exercise_names.empty();
                    if (!runExercise)
                    {
                        auto foundIter = std::find(
                            std::begin(options.exercise_names),
                            std::end(options.exercise_names),
                            exercise.name);
                        runExercise = (foundIter != std::end(options.exercise_names));
                    }
                    if (runExercise)
                    {
                        exercise.exercise_to_run();
                    }
                }
            }
        }
    };
 
} // end namespace
 
//########################################################################
//########################################################################
 
 
int main(int argc, char** argv)
{
    Helpers::enableVTMode();
 
    srand(static_cast<unsigned int>(time(nullptr)));
    DesignPatternExamples_cpp::Program prog;
    StringList args;
    for (int argIndex = 1; argIndex < argc; ++argIndex)
    {
        args.push_back(std::string(argv[argIndex]));
    }
 
    prog.Run(args);
 
    return EXIT_SUCCESS;
}