State_Class.cpp

Go to the documentation of this file.

 
 
#include <iostream>
#include <stdexcept>
#include <exception>
#include <map>
#include <memory>
#include <sstream>
 
#include "helpers/formatstring.h"
 
#include "State_Class.h"
 
namespace // Anonymous
{
    using namespace DesignPatternExamples_cpp;
 
    std::string _CurrentStateToString(CurrentState state)
    {
        std::string stateAsString;
 
        switch (state)
        {
        case CurrentState::Initial:
            stateAsString = "Initial";
            break;
 
        case CurrentState::NormalText:
            stateAsString = "NormalText";
            break;
 
        case CurrentState::DoubleQuotedText:
            stateAsString = "DoubleQuotedText";
            break;
 
        case CurrentState::SingleQuotedText:
            stateAsString = "SingleQuotedText";
            break;
 
        case CurrentState::EscapedDoubleQuoteText:
            stateAsString = "EscapedDoubleQuoteText";
            break;
 
        case CurrentState::EscapedSingleQuoteText:
            stateAsString = "EscapedSingleQuoteText";
            break;
 
        case CurrentState::StartComment:
            stateAsString = "StartComment";
            break;
 
        case CurrentState::LineComment:
            stateAsString = "LineComment";
            break;
 
        case CurrentState::BlockComment:
            stateAsString = "BlockComment";
            break;
 
        case CurrentState::EndBlockComment:
            stateAsString = "EndBlockComment";
            break;
 
        case CurrentState::Done:
            stateAsString = "Done";
            break;
 
        default:
            stateAsString = Helpers::formatstring("Unknown (%d)", static_cast<int>(state));
            break;
        }
 
 
        return stateAsString;
    }
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State class definitions
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
    class State_NormalText : public IStateBehavior
    {
    public:
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::NormalText;
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '"':
                context->OutputCharacter(character);
                nextState = CurrentState::DoubleQuotedText;
                break;
 
            case '\'':
                context->OutputCharacter(character);
                nextState = CurrentState::SingleQuotedText;
                break;
 
            case '/':
                nextState = CurrentState::StartComment;
                break;
 
            default:
                context->OutputCharacter(character);
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_DoubleQuotedText : public IStateBehavior
    {
    public:
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::DoubleQuotedText;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '"':
                context->OutputCharacter(character);
                nextState = CurrentState::NormalText;
                break;
 
            case '\\':
                context->OutputCharacter(character);
                nextState = CurrentState::EscapedDoubleQuoteText;
                break;
 
            default:
                context->OutputCharacter(character);
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_SingleQuotedText : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::SingleQuotedText;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '\'':
                context->OutputCharacter(character);
                nextState = CurrentState::NormalText;
                break;
 
            case '\\':
                context->OutputCharacter(character);
                nextState = CurrentState::EscapedSingleQuoteText;
                break;
 
            default:
                context->OutputCharacter(character);
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_EscapedDoubleQuoteText : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::DoubleQuotedText;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            default:
                context->OutputCharacter(character);
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_EscapedSingleQuoteText : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::SingleQuotedText;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            default:
                context->OutputCharacter(character);
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_StartComment : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::StartComment;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '/':
                nextState = CurrentState::LineComment;
                break;
 
            case '*':
                nextState = CurrentState::BlockComment;
                break;
 
            default:
                // Not the start of a comment so output the leading slash
                // that led to the state followed by the character we just
                // processed.
                context->OutputCharacter('/');
                context->OutputCharacter(character);
                nextState = CurrentState::NormalText;
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_LineComment : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::LineComment;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '\n':
                context->OutputCharacter(character);
                nextState = CurrentState::NormalText;
                break;
 
            default:
                // We are in a comment to be removed, so do nothing here.
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_BlockComment : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::BlockComment;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '*':
                nextState = CurrentState::EndBlockComment;
                break;
 
            default:
                // We are in a comment to be removed, so do nothing here.
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_EndBlockComment : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* context)
        {
            CurrentState nextState = CurrentState::BlockComment;
 
            char character = context->GetNextCharacter();
 
            switch (character)
            {
            case EOF_CHAR:
                nextState = CurrentState::Done;
                break;
 
            case '/':
                nextState = CurrentState::NormalText;
                break;
 
            default:
                // We are still in a block comment to be removed, so do nothing here.
                break;
            }
 
            return nextState;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class State_Done : public IStateBehavior
    {
        CurrentState GoNext(IStateContext* /*context*/)
        {
            // Do nothing (Yes!  Another Null Object example!)
            return CurrentState::Done;
        }
    };
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State class factory definition
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
    class State_Factory
    {
    public:
        static IStateBehavior::shared_ptr_t CreateState(CurrentState state)
        {
            IStateBehavior::shared_ptr_t stateBehavior;
            switch (state)
            {
            case CurrentState::NormalText:
                stateBehavior = std::make_shared<State_NormalText>();
                break;
 
            case CurrentState::DoubleQuotedText:
                stateBehavior = std::make_shared<State_DoubleQuotedText>();
                break;
 
            case CurrentState::SingleQuotedText:
                stateBehavior = std::make_shared<State_SingleQuotedText>();
                break;
 
            case CurrentState::EscapedDoubleQuoteText:
                stateBehavior = std::make_shared<State_EscapedDoubleQuoteText>();
                break;
 
            case CurrentState::EscapedSingleQuoteText:
                stateBehavior = std::make_shared<State_EscapedSingleQuoteText>();
                break;
 
            case CurrentState::StartComment:
                stateBehavior = std::make_shared<State_StartComment>();
                break;
 
            case CurrentState::LineComment:
                stateBehavior = std::make_shared<State_LineComment>();
                break;
 
            case CurrentState::BlockComment:
                stateBehavior = std::make_shared<State_BlockComment>();
                break;
 
            case CurrentState::EndBlockComment:
                stateBehavior = std::make_shared<State_EndBlockComment>();
                break;
 
            case CurrentState::Done:
                stateBehavior = std::make_shared<State_Done>();
                break;
 
            default:
            {
                std::string msg = Helpers::formatstring("Unknown state: %s.  Cannot create a state class.",
                    _CurrentStateToString(state).c_str());
                throw std::runtime_error(msg.c_str());
            }
            }
 
            return stateBehavior;
        }
    };
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State Context implementation class definition
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
    class StateContext_ClassImpl : public IStateContext
    {
    private:
        std::string _inputText;
 
        size_t _textIndex;
 
        std::ostringstream _outputText;
 
        using StateMapping = std::map<CurrentState, IStateBehavior::shared_ptr_t>;
 
        StateMapping _stateBehaviors;
 
        CurrentState _currentState;
 
        IStateBehavior::shared_ptr_t _currentStateBehavior;
 
 
    private:
        //--------------------------------------------------------------------
        // StateContext_Class implementation.
        //--------------------------------------------------------------------
 
        void _SetNextState(CurrentState newState)
 
        {
            if (newState != _currentState)
            {
                StateMapping::const_iterator foundIter = _stateBehaviors.find(newState);
 
                if (foundIter == std::cend(_stateBehaviors))
                {
                    _stateBehaviors[newState] = State_Factory::CreateState(newState);
                }
 
                std::cout
                    << Helpers::formatstring("    --> State Transition: %s -> %s",
                        _CurrentStateToString(_currentState).c_str(),
                        _CurrentStateToString(newState).c_str())
                    << std::endl;
 
                _currentStateBehavior = _stateBehaviors[newState];
                _currentState = newState;
            }
        }
 
 
    public:
        StateContext_ClassImpl()
            : _textIndex(0)
            , _currentState(CurrentState::Initial)
        {
        }
 
 
        //--------------------------------------------------------------------
        // StateContext_Class public entry points.
        //--------------------------------------------------------------------
 
        std::string RemoveComments(std::string text)
        {
            _inputText = text;
            _textIndex = 0;
            _outputText.str("");
            _outputText.clear();
            _currentState = CurrentState::Initial;
            _SetNextState(CurrentState::NormalText);
 
            while (_currentState != CurrentState::Done)
            {
                CurrentState nextState = _currentStateBehavior->GoNext(this);
                _SetNextState(nextState);
            }
 
            return _outputText.str();
        }
 
 
        //--------------------------------------------------------------------
        // IStateContext interface implementation.
        //--------------------------------------------------------------------
 
        char GetNextCharacter()
        {
            char character = EOF_CHAR;
 
            if (_textIndex < _inputText.size())
            {
                character = _inputText[_textIndex];
                ++_textIndex;
            }
            return character;
        }
 
        void OutputCharacter(char character)
        {
            if (character != EOF_CHAR)
            {
                _outputText << character;
            }
        }
    };
 
}
 
 
 
 
namespace DesignPatternExamples_cpp
{
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State Context public class definition
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
    StateContext_Class::StateContext_Class()
    : _stateContextimpl(std::make_unique<StateContext_ClassImpl>())
    {
    }
 
 
    std::string StateContext_Class::RemoveComments(std::string text)
    {
        StateContext_ClassImpl* stateImpl = dynamic_cast<StateContext_ClassImpl*>(_stateContextimpl.get());
        if (stateImpl != nullptr)
        {
            return stateImpl->RemoveComments(text);
        }
        return std::string();
    }
 
} // end namespace