program.c

Go to the documentation of this file.

 
 
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
 
#include <version.h>
 
#include "helpers/enablevtmode.h"
#include "helpers/stringlist.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"
 
typedef void(*Action)(void);
 
typedef struct _Exercise
{
    const char* name;
 
    Action exercise_to_run;
} Exercise;
 
typedef Exercise ExerciseList[];
 
 
typedef struct _Options
{
    StringList exercise_names;
} Options;
 
 
static void Help(ExerciseList exercises)
{
    const char* usage =
        "DesignPatternExamples_c (v" APP_VERSION ") by Stephen P. Lepisto\n"
        "usage: DesignPatternExamples_c [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.
 
    printf("%s\n", usage);
 
    printf("Exercises available:\n");
    for (size_t index = 0; exercises[index].name != NULL; index++)
    {
        printf("  %s\n", exercises[index].name);
    }
}
 
static void ShowVersion(void)
{
    printf("%s\n", APP_VERSION);
}
 
 
static bool ParseOptions(int argc, char** argv, Options* options, ExerciseList exercises)
{
    bool optionsValid = true;
 
    if (options == NULL)
    {
        printf("Error!  ParseOptions() requires non-NULL pointer to the Options structure.\n");
        return false;
    }
 
    if (argc > 1)
    {
        for (int index = 1; index < argc; index++)
        {
            if (strcmp(argv[index], "--help") == 0 ||
                strcmp(argv[index], "-?") == 0 ||
                strcmp(argv[index], "/?") == 0)
            {
                Help(exercises);
                optionsValid = false;
                break;
            }
            if (strcmp(argv[index], "--version") == 0)
            {
                ShowVersion();
                optionsValid = false;
                break;
            }
            if (!StringList_AddString(&options->exercise_names, argv[index]))
            {
                printf("Error!  Out of memory storing exercise name in the Options structure.");
                return false;
            }
        }
    }
 
    return optionsValid;
}
 
 
//########################################################################
//########################################################################
 
ExerciseList exercises =
    {
        {"Adapter", Adapter_Exercise},
        {"Bridge", Bridge_Exercise},
        {"Command", Command_Exercise},
        {"Composite", Composite_Exercise},
        {"Decorator", Decorator_Exercise},
        {"Facade", Facade_Exercise},
        {"Flyweight", Flyweight_Exercise},
        {"HandlerChain", HandlerChain_Exercise},
        {"Interpreter", Interpreter_Exercise},
        {"Iterator", Iterator_Exercise},
        {"Mediator", Mediator_Exercise},
        {"Memento", Memento_Exercise},
        {"NullObject", NullObject_Exercise},
        {"Observer", Observer_Exercise},
        {"Proxy", Proxy_Exercise},
        {"State", State_Exercise},
        {"Strategy", Strategy_Exercise},
        {"Visitor", Visitor_Exercise},
        {NULL, NULL}};
 
int main(int argc, char** argv)
{
    enableVTMode();
    srand((unsigned int)(time(NULL)));
    Options options = { 0 };
    StringList_Initialize(&options.exercise_names);
 
    if (ParseOptions(argc, argv, &options, exercises))
    {
        for (int index = 0; exercises[index].name != NULL; index++)
        {
            bool runExercise = (options.exercise_names.strings_count == 0);
            if (!runExercise)
            {
                runExercise = (StringList_Find(&options.exercise_names, exercises[index].name) != -1);
            }
            if (runExercise)
            {
                exercises[index].exercise_to_run();
            }
        }
    }
    StringList_Clear(&options.exercise_names);
 
    return EXIT_SUCCESS;
}