NullObject_Exercise.c

Go to the documentation of this file.

 
 
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "NullObject_MoveCommandList.h"
#include "NullObject_Exercise.h"
 
 
static void MoveCommand_Show(char commandToken, const char *commandName)
{
    if (commandName != NULL)
    {
        printf("    '%c' -> %s\n", commandToken, commandName);
    }
}
 
 
static void MoveCommandLeft_Execute(void)
{
    printf("move left");
}
 
 
static void MoveCommandRight_Execute(void)
{
    printf("move right");
}
 
 
static void MoveCommandUp_Execute(void)
{
    printf("move up");
}
 
 
static void MoveCommandDown_Execute(void)
{
    printf("move down");
}
 
 
static void MoveCommandNone_Execute(void)
{
    // Do nothing.
}
 
 
 
static bool _MoveProcessor_ParseMoves(const char *moveList, MoveCommandList *commandList)
{
    bool parsed = false;
 
    if (moveList != NULL && commandList != NULL)
    {
        parsed = true;
        size_t moveListSize = strlen(moveList);
        for (size_t index = 0; index < moveListSize; index++)
        {
            char commandChar = (char)toupper(moveList[index]);
            MoveCommand* moveCommand = NULL;
 
            switch (commandChar)
            {
            case 'U':
                moveCommand = MoveCommand_Create(commandChar, "Up", MoveCommandUp_Execute);
                break;
 
            case 'D':
                moveCommand = MoveCommand_Create(commandChar, "Down", MoveCommandDown_Execute);
                break;
 
            case 'L':
                moveCommand = MoveCommand_Create(commandChar, "Left", MoveCommandLeft_Execute);
                break;
 
            case 'R':
                moveCommand = MoveCommand_Create(commandChar, "Right", MoveCommandRight_Execute);
                break;
 
            default:
                // Everything else is a "do nothing" command.
                moveCommand = MoveCommand_Create(commandChar, "None", MoveCommandNone_Execute);
                break;
            }
            if (moveCommand != NULL)
            {
                if (!MoveCommandList_Add(commandList, moveCommand))
                {
                    printf("  Error!  Out of memory condition adding command %c.\n", commandChar);
                    MoveCommandList_Clear(commandList);
                    parsed = false;
                    break;
                }
            }
            else
            {
                printf("  Error!  Out of memory condition creating MoveCommand for command %c.\n", commandChar);
                parsed = false;
                break;
            }
        }
    }
 
    return parsed;
}
 
 
static void _MoveProcessor_ExecuteMoves(MoveCommandList *commands)
{
    if (commands != NULL)
    {
        for (size_t index = 0; index < commands->commands_count; index++)
        {
            MoveCommand* moveCommand = commands->commands[index];
            if (moveCommand->Execute != NULL)
            {
                printf("<");
                moveCommand->Execute();
                printf("> ");
            }
        }
        printf("\n");
    }
}
 
 
static void _MoveProcessor_ShowMoves(MoveCommandList *commands)
{
    if (commands != NULL)
    {
        for (size_t index = 0; index < commands->commands_count; index++)
        {
            MoveCommand* moveCommand = commands->commands[index];
            MoveCommand_Show(moveCommand->commandToken, moveCommand->commandName);
        }
    }
}
 
static void MoveProcessor_ExecuteMoveList(const char *moveList)
{
    MoveCommandList commandList;
 
    MoveCommandList_Initialize(&commandList);
 
    if (_MoveProcessor_ParseMoves(moveList, &commandList))
    {
        _MoveProcessor_ExecuteMoves(&commandList);
    }
    MoveCommandList_Clear(&commandList);
}
 
 
static void MoveProcessor_ShowMoveList(const char *moveList)
{
    MoveCommandList commandList;
    MoveCommandList_Initialize(&commandList);
    if (_MoveProcessor_ParseMoves(moveList, &commandList))
    {
        _MoveProcessor_ShowMoves(&commandList);
    }
    MoveCommandList_Clear(&commandList);
}
 
 
//=============================================================================
//=============================================================================
 
// ! [Using NullObject in C]
void NullObject_Exercise(void)
{
    printf("\nNullObject Exercise\n");
 
    // A stream of recognized and unrecognized move commands.  The
    // unrecognized commands do nothing.
    const char* moveString = "ur#ld!lr";
    printf("  Showing the move commands:\n");
    MoveProcessor_ShowMoveList(moveString);
 
    printf("  Executing the move commands:\n");
    printf("    %s -> ", moveString);
    MoveProcessor_ExecuteMoveList(moveString);
 
    printf("  Done.\n");
}
// ! [Using NullObject in C]