예제 #1
0
            private SubExpression[] GetSubs()
            {
                var se = new List <SubExpression>();
                var currentExpression = string.Empty;

                for (var i = 0; i < ExpressionString.Length; i++)
                {
                    if (ExpressionValues.IsMathSymbol(ExpressionString[i]))
                    {
                        if (!string.IsNullOrWhiteSpace(currentExpression))
                        {
                            se.Add(new SubExpression(currentExpression, this));
                            currentExpression = string.Empty;
                        }
                        se.Add(new SubExpression(ExpressionString[i].ToString(), this));
                    }
                    else
                    {
                        currentExpression += ExpressionString[i];
                    }
                }

                if (!string.IsNullOrWhiteSpace(currentExpression))
                {
                    se.Add(new SubExpression(currentExpression, this));
                }

                return(se.ToArray());
            }
예제 #2
0
            public SubExpression[] GetSubExpressions()
            {
                if (string.IsNullOrWhiteSpace(ExpressionString))
                {
                    return(null);
                }

                if (!ExpressionString.Contains('(') && !ExpressionString.Contains(')'))
                {
                    return(GetSubs());
                }

                var subs = 0;
                var currentExpression = string.Empty;
                var result            = new List <SubExpression>();

                for (var i = 0; i < ExpressionString.Length; i++)
                {
                    var c = ExpressionString[i];

                    if (c == '(')
                    {
                        subs++;

                        if (subs == 1)
                        {
                            if (!string.IsNullOrWhiteSpace(currentExpression))
                            {
                                result.Add(new SubExpression(currentExpression, this));
                            }
                            currentExpression = string.Empty;
                        }
                        else
                        {
                            currentExpression += c;
                        }
                    }
                    else if (c == ')')
                    {
                        subs--;


                        if (subs == 0)
                        {
                            if (!string.IsNullOrWhiteSpace(currentExpression))
                            {
                                result.Add(new SubExpression(currentExpression, this));
                            }
                            currentExpression = string.Empty;
                        }
                        else
                        {
                            currentExpression += c;
                        }
                    }
                    else if (ExpressionValues.IsMathSymbol(c) && subs == 0)
                    {
                        if (!string.IsNullOrWhiteSpace(currentExpression))
                        {
                            result.Add(new SubExpression(currentExpression, this));
                        }
                        currentExpression = string.Empty;
                        result.Add(new SubExpression(c.ToString(), this));
                    }
                    else
                    {
                        currentExpression += c;
                    }
                }

                if (!string.IsNullOrWhiteSpace(currentExpression))
                {
                    result.Add(new SubExpression(currentExpression, this));
                }

                if (result.Count == 1 && result[0].ExpressionString == ExpressionString)
                {
                    return(null);
                }

                return(result.ToArray());
            }