public IDelimiterStateMachine Process(string input, int pos, DelimiterState targetRegion, StringBuilder output)
        {
            output.Append(input[pos]);
            switch (input[pos])
            {
            case '"': return(new CharStateOther());

            default: return(this);
            }
        }
        public void ReadDelimiterCharTest()
        {
            char[]         buffer         = new char[1];
            int            bufferPosition = 0;
            DelimiterState target         = new DelimiterState(',', new EndState());

            StateReader resultState = target.ReadChar(',', ref buffer, ref bufferPosition);

            Assert.AreNotEqual(',', buffer[0]);
            Assert.IsTrue(resultState is EndState);
        }
        public void ReadEndOfNewLineCharTest()
        {
            char[]      buffer         = new char[2];
            int         bufferPosition = 0;
            StateReader target         = new DelimiterState(',', new EndState());

            target = target.ReadChar('\r', ref buffer, ref bufferPosition);

            Assert.AreNotEqual('\r', buffer[0]);
            Assert.AreEqual(0, bufferPosition);
            Assert.IsTrue(target is EndNewLinePatternState);

            target = target.ReadChar('\n', ref buffer, ref bufferPosition);

            Assert.AreNotEqual('\n', buffer[0]);
            Assert.AreEqual(0, bufferPosition);
            Assert.IsTrue(target is EndNewLinePatternState);
        }
        public static string Translate(string input, DelimiterState targetDelimiter)
        {
            // from European
            // ; -> ,
            // , -> .
            // from English
            // , -> ;
            // . -> ,
            // TopPercent( 10.0,

            StringBuilder output = new StringBuilder(input.Length);

            IDelimiterStateMachine currentState = new CharStateOther();

            for (int i = 0; i < input.Length; i++)
            {
                currentState = currentState.Process(input, i, targetDelimiter, output);
            }
            return(output.ToString());
        }
        public IDelimiterStateMachine Process(string input, int pos, DelimiterState targetRegion, StringBuilder output)
        {
            switch (input[pos])
            {
            case '"':
                output.Append(input[pos]);
                return(new CharStateString());

            case '\'':
                output.Append(input[pos]);
                return(new CharStateTable());

            case '[':
                output.Append(input[pos]);
                return(new CharStateColumn());

            case ';':
                if (targetRegion == DelimiterState.Unknown)
                {
                    targetRegion = DelimiterState.Comma;
                }
                if (targetRegion == DelimiterState.Comma)
                {
                    output.Append(',');
                }
                else
                {
                    output.Append(input[pos]);
                }
                return(this);

            case '.':
                if (targetRegion == DelimiterState.Unknown)
                {
                    if (pos > 0 && pos < input.Length - 1 && IsNumeric(input[pos - 1]) && IsNumeric(input[pos + 1]))
                    {
                        targetRegion = DelimiterState.SemiColon;
                    }
                }
                if (targetRegion == DelimiterState.SemiColon)
                {
                    output.Append(',');
                }
                if (targetRegion == DelimiterState.Comma)
                {
                    output.Append(input[pos]);
                }
                return(this);

            case ',':
                if (targetRegion == DelimiterState.Unknown)
                {
                    if (pos > 0 && pos < input.Length - 1 && IsNumeric(input[pos - 1]) && IsNumeric(input[pos + 1]))
                    {
                        targetRegion = DelimiterState.Comma;
                    }
                    else
                    {
                        targetRegion = DelimiterState.SemiColon;
                    }
                }
                switch (targetRegion)
                {
                case DelimiterState.SemiColon:
                    output.Append(';');
                    break;

                case DelimiterState.Comma:
                    output.Append('.');
                    break;

                default:
                    output.Append(input[pos]);
                    break;
                }

                return(this);

            default:
                output.Append(input[pos]);
                return(this);
            }
        }