State_Class.cs

Go to the documentation of this file.

 
 
using System;
using System.Collections.Generic;
using System.Text;
 
 
namespace DesignPatternExamples_csharp
{
    enum CurrentState
    {
        Initial,                
        NormalText,             
        DoubleQuotedText,       
        SingleQuotedText,       
        EscapedDoubleQuoteText, 
        EscapedSingleQuoteText, 
        StartComment,           
        LineComment,            
        BlockComment,           
        EndBlockComment,        
        Done                    
    }
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // Interface definitions
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    internal class State_Constants
    {
        public const char EOF = (char)0xff;
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal interface IStateContext
    {
        char GetNextCharacter();
 
        void OutputCharacter(char character);
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal interface IStateBehavior
    {
        CurrentState GoNext(IStateContext context);
    }
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State class definitions
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
    internal class State_NormalText : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.NormalText;
            char character = context.GetNextCharacter();
 
            switch(character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_DoubleQuotedText : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.DoubleQuotedText;
 
            char character = context.GetNextCharacter();
 
            switch(character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_SingleQuotedText : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.SingleQuotedText;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_EscapedDoubleQuoteText : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.DoubleQuotedText;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    nextState = CurrentState.Done;
                    break;
 
                default:
                    context.OutputCharacter(character);
                    break;
            }
 
            return nextState;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_EscapedSingleQuoteText : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.SingleQuotedText;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    nextState = CurrentState.Done;
                    break;
 
                default:
                    context.OutputCharacter(character);
                    break;
            }
 
            return nextState;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_StartComment : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.StartComment;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_LineComment : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.LineComment;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_BlockComment : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.BlockComment;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_EndBlockComment : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            CurrentState nextState = CurrentState.BlockComment;
 
            char character = context.GetNextCharacter();
 
            switch (character)
            {
                case State_Constants.EOF:
                    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;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class State_Done : IStateBehavior
    {
        CurrentState IStateBehavior.GoNext(IStateContext context)
        {
            // Do nothing (Yes!  Another Null Object example!)
            return CurrentState.Done;
        }
    }
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State class factory definition
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        
    static internal class State_Factory
    {
        static public IStateBehavior CreateState(CurrentState state)
        {
            IStateBehavior stateBehavior;
            switch(state)
            {
                case CurrentState.NormalText:
                    stateBehavior = new State_NormalText();
                    break;
 
                case CurrentState.DoubleQuotedText:
                    stateBehavior = new State_DoubleQuotedText();
                    break;
 
                case CurrentState.SingleQuotedText:
                    stateBehavior = new State_SingleQuotedText();
                    break;
 
                case CurrentState.EscapedDoubleQuoteText:
                    stateBehavior = new State_EscapedDoubleQuoteText();
                    break;
 
                case CurrentState.EscapedSingleQuoteText:
                    stateBehavior = new State_EscapedSingleQuoteText();
                    break;
 
                case CurrentState.StartComment:
                    stateBehavior = new State_StartComment();
                    break;
 
                case CurrentState.LineComment:
                    stateBehavior = new State_LineComment();
                    break;
 
                case CurrentState.BlockComment:
                    stateBehavior = new State_BlockComment();
                    break;
 
                case CurrentState.EndBlockComment:
                    stateBehavior = new State_EndBlockComment();
                    break;
 
                case CurrentState.Done:
                    stateBehavior = new State_Done();
                    break;
 
                default:
                    throw new ApplicationException(string.Format("Unknown state: {0}.  Cannot create a state class.", state));
            }
 
            return stateBehavior;
        }
    }
 
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // State context definition
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
    public class StateContext_Class : IStateContext
    {
        private string _inputText = string.Empty;
 
        private int _textIndex = 0;
 
        private StringBuilder _outputText = new StringBuilder();
 
        private Dictionary<CurrentState, IStateBehavior> _stateBehaviors = new Dictionary<CurrentState, IStateBehavior>();
 
        private CurrentState _currentState;
 
        private IStateBehavior _currentStateBehavior = new State_NormalText();
 
 
        //--------------------------------------------------------------------
        // StateContext_Class implementation.
        //--------------------------------------------------------------------
 
        private void _SetNextState(CurrentState newState)
        {
            if (newState != _currentState)
            {
                if (!_stateBehaviors.ContainsKey(newState))
                {
                    _stateBehaviors[newState] = State_Factory.CreateState(newState);
                }
 
                Console.WriteLine("    --> State Transition: {0} -> {1}", _currentState, newState);
 
                _currentStateBehavior = _stateBehaviors[newState];
                _currentState = newState;
            }
        }
 
 
        //--------------------------------------------------------------------
        // StateContext_Class public entry points.
        //--------------------------------------------------------------------
            
        public string RemoveComments(string text)
        {
            _inputText = text;
            _textIndex = 0;
            _outputText = new StringBuilder();
            _currentState = CurrentState.Initial;
            _SetNextState(CurrentState.NormalText);
 
            while (_currentState != CurrentState.Done)
            {
                CurrentState nextState = _currentStateBehavior.GoNext(this);
                _SetNextState(nextState);
            }
 
            return _outputText.ToString();
        }
 
 
        //--------------------------------------------------------------------
        // IStateContext interface implementation.
        //--------------------------------------------------------------------
        // Note: These methods are accessible only through the IStateContext
        // interface so are not directly available on the StateContext_Class
        // instance.
 
        char IStateContext.GetNextCharacter()
        {
            char character = State_Constants.EOF;
 
            if (_textIndex < _inputText.Length)
            {
                character = _inputText[_textIndex];
                ++_textIndex;
            }
            return character;
        }
 
        void IStateContext.OutputCharacter(char character)
        {
            if (character != State_Constants.EOF)
            {
                _outputText.Append(character);
            }
        }
    }
}