Memento_Exercise.c

Go to the documentation of this file.

 
 
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "helpers/formatstring.h"
#include "helpers/stack.h"
#include "helpers/replace.h"
 
#include "Memento_Memento.h"
#include "Memento_TextObject.h"
#include "Memento_Exercise.h"
 
//=============================================================================
//=============================================================================
 
static StackEntry* _mementoUndoList = NULL;
 
static void Memento_SaveForUndo(Memento_TextObject* text, const char* operation)
{
    if (text != NULL && operation != NULL)
    {
        Memento* memento = Memento_Create(Memento_TextObject_GetText(text), operation);
        if (memento != NULL)
        {
            Stack_Push(&_mementoUndoList, memento);
        }
    }
}
 
 
static void Memento_Operation_Replace(Memento_TextObject* source, const char* searchPattern, const char* replaceText)
{
    if (source != NULL && searchPattern != NULL && replaceText != NULL)
    {
        char* newText = replace_str(Memento_TextObject_GetText(source), searchPattern, replaceText);
        if (newText != NULL)
        {
            Memento_TextObject_SetText(source, newText);
            free(newText);
        }
    }
}
 
static void Memento_Operation_Reverse(Memento_TextObject* source)
{
    if (source != NULL)
    {
        // We will change the text object in-place because we can.
        char* text = Memento_TextObject_GetText(source);
 
        size_t textSize = strlen(text);
        size_t halftextSize = textSize / 2;
        for (size_t index = 0; index < halftextSize; ++index)
        {
            char c = text[index];
            text[index] = text[textSize - index - 1];
            text[textSize - index - 1] = c;
        }
    }
}
 
static void Memento_Undo(Memento_TextObject* text)
{
    if (text != NULL)
    {
        if (_mementoUndoList != NULL)
        {
            Memento* lastMemento = Stack_Pop(&_mementoUndoList);
            Memento_TextObject_SetText(text, lastMemento->text);
 
            // Show off what we (un)did.
            printf("    undoing operation %-31s: \"%s\"\n", lastMemento->name, Memento_TextObject_ToString(text));
            Memento_Destroy(lastMemento);
        }
    }
}
 
static void Memento_ApplyReplaceOperation(Memento_TextObject* text, const char* searchPattern, const char* replaceText)
{
    if (text != NULL && searchPattern != NULL && replaceText != NULL)
    {
        char *operationName = formatstring("Replace '%s' with '%s'", searchPattern, replaceText);
        if (operationName != NULL)
        {
            Memento_SaveForUndo(text, operationName);
            Memento_Operation_Replace(text, searchPattern, replaceText);
            printf("    operation %-31s: \"%s\"\n", operationName, Memento_TextObject_ToString(text));
            free(operationName);
        }
        else
        {
            printf("  Error! Out of memory while creating operation name for replace operation!\n");
        }
    }
}
 
 
static void Memento_ApplyReverseOperation(Memento_TextObject* text)
{
    const char* operationName = "Reverse";
    Memento_SaveForUndo(text, operationName);
    Memento_Operation_Reverse(text);
    printf("    operation %-31s: \"%s\"\n", operationName, Memento_TextObject_ToString(text));
}
 
//=============================================================================
//=============================================================================
 
// ! [Using Memento in C]
void Memento_Exercise(void)
{
    printf("\nMemento_Exercise\n");
 
    _mementoUndoList = NULL;
 
    // The base text object to work from.
    Memento_TextObject* text = Memento_TextObject_Create("This is a line of text on which to experiment.");
    if (text != NULL)
    {
        printf("  Starting text: \"%s\"\n", Memento_TextObject_ToString(text));
 
        // Apply four operations to the text.
        Memento_ApplyReplaceOperation(text, "text", "painting");
        Memento_ApplyReplaceOperation(text, "on", "off");
        Memento_ApplyReverseOperation(text);
        Memento_ApplyReplaceOperation(text, "i", "!");
 
        printf("  Now perform undo until back to original\n");
 
        // Now undo the four operations.
        Memento_Undo(text);
        Memento_Undo(text);
        Memento_Undo(text);
        Memento_Undo(text);
 
        printf("  Final text   : \"%s\"\n", Memento_TextObject_ToString(text));
 
        Memento_TextObject_Destroy(text);
    }
 
    printf("  Done.\n");
}
// ! [Using Memento in C]